Datasets:

xlangai

/

the-stack-vault

like 0

f7414e3f469f6d399018e369e8cc8df87c4996fc

py

Python

gorillabot/plugins/link.py

pep7/GorillaBot

b29ae1f05423494f7e122906efe24e9ffcd1421e

gorillabot/plugins/link.py

pep7/GorillaBot

b29ae1f05423494f7e122906efe24e9ffcd1421e

gorillabot/plugins/link.py

pep7/GorillaBot

b29ae1f05423494f7e122906efe24e9ffcd1421e

# Copyright (c) 2013-2016 Molly White # # 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. from plugins.util import command, get_url from urllib.parse import quote from html import unescape from datetime import datetime import json import re @command() def link(m, urls=None, wikilinks=None): """Retrieve a description of the link, or provide a link to the English Wikipedia article if formatted as a wikilink.""" #- !link URL #- #- ```irc #- < GorillaWarfare> !link http://molly.github.io/GorillaBot/ #- < GorillaBot> Link: GorillaBot #- < GorillaWarfare> !link https://www.youtube.com/watch?v=aSarf4-REgk #- < GorillaBot> Link: "Baby Gorilla Reunites With Mother" (01:43). Uploaded Mar 24, #- 2014. 164347 views. 513 likes, 32 dislikes. #- < GorillaWarfare> !link [[Gorilla]] #- < GorillaBot> https://en.wikipedia.org/wiki/Gorilla #- ``` #- #- Provide information about the given link, or provide a link to the English Wikipedia article #- if formatted as a wikilink. #- #- In order to provide rich information about YouTube videos, you must provide a YouTube API #- key when configuring the bot. You can get an API key by registering a project in the [ #- Google Developer Console](https://console.developers.google.com/). Without a key, #- the normal linking will be used. #- #- #### Settings #- * `auto` - All links and wikilinks entered in the chat will be parsed, regardless of whether #- they're prefaced with `!link`. if not (urls or wikilinks): urls = re.findall(r'(https?://\S+)', m.body) wikilinks = re.findall(r'\[{2}(.*?)\]{2}', m.body) if not (urls or wikilinks): m.bot.private_message(m.location, "Please provide a link.") return for url in urls: if "youtube.com" in url or "youtu.be" in url: message = youtube(m, url) elif "reddit.com" in url: message = reddit(m, url) else: message = generic(m, url) if message: m.bot.private_message(m.location, "Link: " + clean(message)) for wikilink in wikilinks: safe = wikilink.replace(" ", "_") if safe[-1] == ")": safe = safe[:-1] + "%29" m.bot.private_message(m.location, "https://en.wikipedia.org/wiki/" + safe) @command("relevantxkcd") def xkcd(m): """Get an xkcd comic based on given arguments.""" #- !xkcd [number|query] #- #- ```irc #- < GorillaWarfare> !xkcd batman acne #- < GorillaBot> xkcd: Complexion: http://xkcd.com/700/ #- < GorillaWarfare> !xkcd 700 #- < GorillaBot> xkcd: Complexion: http://xkcd.com/700/ #- < GorillaWarfare> !xkcd #- < GorillaBot> xkcd: Telescope Names: http://xkcd.com/1294/ #- ``` #- #- Without any arguments, this provides a random xkcd comic. When a number is supplied, #- it tries to return the xkcd comic with that given number. When a query string is supplied, #- it tries to return the xkcd comic that most closely matches that query. if len(m.line) == 1: url = "http://c.xkcd.com/random/comic/" html = get_url(m, url) message = xkcd_direct(html) if message is None: m.bot.logger.error("Couldn't get random xkcd comic.") message = "Sorry, I'm broken. Tell GorillaWarfare to fix me." elif len(m.line) == 2 and m.line[1].isdigit(): url = "http://xkcd.com/{0}/".format(m.line[1]) html = get_url(m, url) if html is None: m.bot.private_message(m.location, "There is no xkcd #{0}.".format(m.line[1])) return message = xkcd_direct(html, url) if message is None: m.bot.logger.error("Couldn't get xkcd comic #{0}.".format(m.line[1])) message = "Sorry, I'm broken. Tell GorillaWarfare to fix me." else: query = " ".join(m.line[1:]) url = 'https://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=site:xkcd.com%20{' \ '0}'.format(quote(query)) html = get_url(m, url) message = xkcd_google(html) m.bot.private_message(m.location, message) def clean(title): """Clean the title so entities are unescaped and there's no weird spacing.""" return unescape(re.sub('[\s]+', ' ', title)) def youtube(m, url): """Retrieve information about the YouTube video.""" api_key = m.bot.configuration["youtube"] if api_key: match = re.search(r'youtu(?:be.com/watch\?v=|\.be/)(.+?)(?:\?|&|\Z)', url) if match: video_id = match.group(1) m.bot.logger.info("Retrieving information from the YouTube API for {}.".format(url)) api_url = "https://www.googleapis.com/youtube/v3/videos?id={id}" \ "&key={key}&part=snippet,contentDetails,statistics" resp = get_url(m, api_url.format(id=video_id, key=api_key)) if resp: # Load JSON blob = json.loads(resp)["items"][0] # Parse uploaded time raw_time = datetime.strptime(blob["snippet"]["publishedAt"], "%Y-%m-%dT%H:%M:%S.%fZ") pretty_time = raw_time.strftime("%b %d, %Y") # Parse video duration dur_match = re.match(r'PT(?:(\d+)H)?(?:(\d+)M)?(\d+)S', blob["contentDetails"]["duration"]) if dur_match: hr, min, sec = dur_match.groups() if hr: pretty_dur = ":".join([hr, "00" if min is None else min.zfill(2), sec.zfill(2)]) else: pretty_dur = ":".join(["00" if min is None else min.zfill(2), sec.zfill(2)]) else: pretty_dur = "" # Format and return message return "\"{title}\" ({duration}). Uploaded {date}. {views} views. {likes} likes, " \ "{dislikes} dislikes.".format(title=blob["snippet"]["title"], duration=pretty_dur, date=pretty_time, views=blob["statistics"]["viewCount"], likes=blob["statistics"]["likeCount"], dislikes=blob["statistics"]["dislikeCount"]) # If there's no API key stored, or the URL is poorly formatted, fall back to generic linking return generic(m, url) def reddit(m, url): """Retrieve information about the Reddit link.""" # I'm sorry reddit_regex = re.compile(r'reddit\.com/(?:u(?:ser)?/(?P<user>.+?)(?:\Z|#|/)|r/(?P<sub>.+?)' r'(?:/?\Z|/comments/(?P<id>.+?)(?:/?\Z|/(?P<title>.+?)' r'(?:/?\Z|/(?P<cid>.+?)(?:/|#|\Z)))))') match = re.search(reddit_regex, url) if match: m.bot.logger.info("Retrieving information from the Reddit API for {}.".format(url)) if match.group("user"): api_url = "http://www.reddit.com/user/{}/about.json" user = match.group("user") resp = get_url(m, api_url.format(user)) blob = json.loads(resp)["data"] return "User {name}: {link_karma} link karma, {comment_karma} comment " \ "karma.".format(**blob) else: api_url = "http://www.reddit.com/api/info.json?id={}" sub, id, cid = match.group("sub"), match.group("id"), match.group("cid") if cid: resp = get_url(m, api_url.format("t1_" + cid)) blob = json.loads(resp)["data"]["children"][0]["data"] parent_resp = get_url(m, api_url.format("t3_" + id)) parent_blob = json.loads(parent_resp)["data"]["children"][0]["data"] parent_blob["nsfw"] = " \x0304[NSFW]\x03" if parent_blob["over_18"] else "" return "Comment by {user} on \"{title}\"{nsfw} in /r/{sub}. {up}↑.".format( user=blob["author"], title=parent_blob["title"], nsfw=parent_blob["nsfw"], sub=blob["subreddit"], up=blob["ups"]) elif id: resp = get_url(m, api_url.format("t3_" + id)) blob = json.loads(resp)["data"]["children"][0]["data"] blob["nsfw"] = "\x0304[NSFW]\x03" if blob["over_18"] else "" return "\"{title}\" in /r/{subreddit}. {ups}↑. {nsfw}".format(**blob) else: api_url = "http://www.reddit.com/r/{}/about.json" resp = get_url(m, api_url.format(sub)) blob = json.loads(resp)["data"] blob["nsfw"] = "\x0304[NSFW]\x03" if blob["over18"] else "" return "/r/{display_name}. {title}. {subscribers} subscribers." \ " {nsfw}".format(**blob) return generic(m, url) def generic(m, url): """Retrieve the title of the webpage.""" m.bot.logger.info("Retrieving link for {}.".format(url)) html = get_url(m, url, True) if html: title_regex = re.compile(r'<title>(.+?)</title>', re.DOTALL) match = re.search(title_regex, html) if match: return match.group(1) else: m.bot.logger.info("No title element found.") return None def xkcd_direct(html, url=None): """Try to return a title and link for a direct link to an xkcd comic.""" if not html: return None if not url: url_match = re.search(r'Permanent link to this comic: ([^\s<>]+)', html) if url_match: url = url_match.group(1) else: return None match = re.search(r'<title>(.+?)</title>', html) if match: return match.group(1) + ": " + url else: return None def xkcd_google(html): """Try to pull out the first Google result for an xkcd comic.""" blob = json.loads(html) results = blob['responseData']['results'] if results == []: return "Could not retrieve xkcd using this query." else: return results[0]['titleNoFormatting'] + ': ' + results[0]['unescapedUrl']

f74188f78260ec762de0025163fd477eb97cc78e

py

Python

examples/transfer_bo.py

zhanglei1172/bbobenchmark

841bffdddc1320ac2676e378d20f8b176a7e6cf7

2021-09-06T02:06:22.000Z

2021-12-09T10:46:56.000Z

examples/transfer_bo.py

zhanglei1172/bbobenchmark

841bffdddc1320ac2676e378d20f8b176a7e6cf7

examples/transfer_bo.py

zhanglei1172/bbobenchmark

841bffdddc1320ac2676e378d20f8b176a7e6cf7

import numpy as np # import matplotlib.pyplot as plt from xbbo.configspace.space import DenseConfiguration, DenseConfigurationSpace from ConfigSpace.hyperparameters import UniformFloatHyperparameter from ConfigSpace.conditions import LessThanCondition # from xbbo.search_algorithm.transfer_tst_optimizer import SMBO # from xbbo.search_algorithm.transfer_taf_optimizer import SMBO # from xbbo.search_algorithm.transfer_rgpe_mean_optimizer import SMBO # from xbbo.search_algorithm.transfer_taf_rgpe_optimizer import SMBO # from xbbo.search_algorithm.transfer_RMoGP_optimizer import SMBO from xbbo.search_algorithm.transfer_bo_optimizer import SMBO from xbbo.search_space.offline_hp import Model from xbbo.utils.constants import MAXINT from xbbo.surrogate.transfer.base_surrogate import BaseModel def rosenbrock_2d(x): """ The 2 dimensional Rosenbrock function as a toy model The Rosenbrock function is well know in the optimization community and often serves as a toy problem. It can be defined for arbitrary dimensions. The minimium is always at x_i = 1 with a function value of zero. All input parameters are continuous. The search domain for all x's is the interval [-5, 10]. """ x1 = x["x0"] # x2 = x["x1"] x2 = x.get('x1', x1) val = 100. * (x2 - x1 ** 2.) ** 2. + (1 - x1) ** 2. return val def branin(config): x1, x2 = config['x1'], config['x2'] y = (x2 - 5.1 / (4 * np.pi ** 2) * x1 ** 2 + 5 / np.pi * x1 - 6) ** 2 \ + 10 * (1 - 1 / (8 * np.pi)) * np.cos(x1) + 10 return y def build_space(rng): cs = DenseConfigurationSpace(seed=rng.randint(10000)) x0 = UniformFloatHyperparameter("x0", -5, 10, default_value=-3) x1 = UniformFloatHyperparameter("x1", -5, 10, default_value=-4) cs.add_hyperparameters([x0, x1]) con = LessThanCondition(x1, x0, 1.) cs.add_condition(con) return cs def build_branin_space(rng): cs = DenseConfigurationSpace(seed=rng.randint(10000)) x1 = UniformFloatHyperparameter("x1", -5, 10, default_value=0) x2 = UniformFloatHyperparameter("x2", 0, 15, default_value=0) cs.add_hyperparameters([x1, x2]) return cs if __name__ == "__main__": MAX_CALL = 30 rng = np.random.RandomState(42) test_model = Model(None, rng.randint(MAXINT), test_task='a6a', ) cs = DenseConfigurationSpace(seed=rng.randint(MAXINT)) confs = test_model.get_api_config() for conf in confs: cs.add_hyperparameter(UniformFloatHyperparameter(conf, confs[conf]['range'][0], confs[conf]['range'][1])) blackbox_func = test_model.evaluate base_models = [] for i in range(len(test_model.old_D_x)): base_models.append(BaseModel(cs, rng=rng,do_optimize=False)) base_models[-1].train(test_model.old_D_x[i], test_model.old_D_y[i]) # use transfer # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='ei', weight_srategy='kernel', acq_opt='rs', base_models=base_models) # vanila bo # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='tst', acq_func='ei', weight_srategy='kernel', acq_opt='rs', base_models=base_models) # TST-R # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='taf', weight_srategy='kernel', acq_opt='rs', base_models=base_models) # TAF # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='tst', acq_func='ei', weight_srategy='rw', acq_opt='rs', base_models=base_models) # RGPE(mean) # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='taf', weight_srategy='rw', acq_opt='rs', base_models=base_models) # TAF(rw) hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_func='mogp', weight_srategy='rw', acq_opt='rs', base_models=base_models) # RMoGP # not use transfer # hpopt = SMBO(space=cs, seed=rng.randint(10000), total_limit=MAX_CALL, initial_design='sobol', surrogate='gp', acq_opt='rs_ls', base_models=[]]) # Example call of the black-box function def_value = blackbox_func(cs.get_default_configuration()) print("Default Value: %.2f" % def_value) # ---- Begin BO-loop ---- for i in range(MAX_CALL): # suggest trial_list = hpopt.suggest() # evaluate value = blackbox_func(trial_list[0].config_dict) # observe trial_list[0].add_observe_value(observe_value=value) hpopt.observe(trial_list=trial_list) print(value) # plt.plot(hpopt.trials.get_history()[0]) # plt.savefig('./out/rosenbrock_bo_gp.png') # plt.show() print('find best value:{}'.format(hpopt.trials.get_best()[0]))

f741a188fda6bef0c338259d1d5661b648d7d929

py

Python

route/__init__.py

0xwhoami/growtopia-chemsynth-router

08ad29ccd3ec6b36ddb48662f84073102392979f

route/__init__.py

0xwhoami/growtopia-chemsynth-router

08ad29ccd3ec6b36ddb48662f84073102392979f

route/__init__.py

0xwhoami/growtopia-chemsynth-router

08ad29ccd3ec6b36ddb48662f84073102392979f

#!/usr/bin/env python """ Copyright (c) 2020-End_Of_Life See the file 'LICENSE' for copying permission """

f741b19a862036a25420498abb6c38930096315b

py

Python

src/infi/pyutils/lazy.py

jasonjorge/infi.asi

78a4c34a421102f99b959a659cf7303804627d9b

2022-02-12T20:30:55.000Z

2022-02-12T20:30:55.000Z

src/infi/pyutils/lazy.py

jasonjorge/infi.asi

78a4c34a421102f99b959a659cf7303804627d9b

2015-11-08T14:50:42.000Z

2020-06-23T14:42:33.000Z

src/infi/pyutils/lazy.py

jasonjorge/infi.asi

78a4c34a421102f99b959a659cf7303804627d9b

2015-02-22T09:06:59.000Z

2022-02-12T20:30:55.000Z

# Adapted from http://wiki.python.org/moin/PythonDecoratorLibrary#Cached_Properties import itertools import time from .decorators import wraps from .python_compat import iteritems from logging import getLogger from types import MethodType, FunctionType logger = getLogger(__name__) class cached_property(object): """Decorator for read-only properties evaluated only once. It can be used to created a cached property like this:: import random # the class containing the property must be a new-style class class MyClass(object): # create property whose value is cached for ten minutes @cached_method def randint(self): # will only be evaluated every 10 min. at maximum. return random.randint(0, 100) The value is cached in the '_cache' attribute of the object inst that has the property getter method wrapped by this decorator. The '_cache' attribute value is a dictionary which has a key for every property of the object which is wrapped by this decorator. Each entry in the cache is created only when the property is accessed for the first time and is a two-element tuple with the last computed property value and the last time it was updated in seconds since the epoch. To expire a cached property value manually just do:: del inst._cache[<property name>] """ def __init__(self, fget, doc=None): super(cached_property, self).__init__() self.fget = fget self.__doc__ = doc or fget.__doc__ self.__name__ = fget.__name__ self.__module__ = fget.__module__ def __get__(self, inst, owner): try: value = inst._cache[self.__name__] except (KeyError, AttributeError): value = self.fget(inst) try: cache = inst._cache except AttributeError: cache = inst._cache = {} cache[self.__name__] = value return value _cached_method_id_allocator = itertools.count() def _get_instancemethod_cache_entry(method_id, *args, **kwargs): if len(args) + len(kwargs) == 0: return method_id try: kwargs_keys = list(kwargs.keys()) kwargs_keys.sort() key = (method_id,) + args + tuple([kwargs[key] for key in kwargs_keys]) _ = {key: None} return key except TypeError: return None def cached_method(func): """Decorator that caches a method's return value each time it is called. If called later with the same arguments, the cached value is returned, and not re-evaluated. """ method_id = next(_cached_method_id_allocator) @wraps(func) def callee(inst, *args, **kwargs): key = _get_instancemethod_cache_entry(method_id, *args, **kwargs) if key is None: logger.debug("Passed arguments to {0} are mutable, so the returned value will not be cached".format(func.__name__)) return func(inst, *args, **kwargs) try: value = inst._cache[key] except (KeyError, AttributeError): value = func(inst, *args, **kwargs) try: inst._cache[key] = value except AttributeError: inst._cache = {} inst._cache[key] = value return value callee.__cached_method__ = True callee.__method_id__ = method_id return callee class cached_method_with_custom_cache(object): def __init__(self, cache_class=None): if cache_class is None: cache_class = dict self.cache_class = cache_class def __call__(self, func): """Decorator that caches a method's return value each time it is called. If called later with the same arguments, the cached value is returned, and not re-evaluated. decorated class must implement inst.init_cache() which creates inst._cache dictionary. """ method_id = next(_cached_method_id_allocator) @wraps(func) def callee(inst, *args, **kwargs): key = _get_instancemethod_cache_entry(method_id, *args, **kwargs) func_name = func.__name__ if key is None: logger.debug("Passed arguments to {0} are mutable, so the returned value will not be cached".format(func_name)) return func(inst, *args, **kwargs) try: return inst._cache[func_name][key] except (KeyError, AttributeError): value = func(inst, *args, **kwargs) if not hasattr(inst, "_cache"): inst._cache = CacheData() if inst._cache.get(func_name, None) is None: #cache class creator returns a dict inst._cache[func_name] = self.cache_class() inst._cache[func_name][key] = value return value callee.__cached_method__ = True callee.__method_id__ = method_id return callee def _get_function_cache_entry(args, kwargs): return (tuple(args), frozenset(iteritems(kwargs))) def cached_function(func): """Decorator that caches a function's return value each time it is called. If called later with the same arguments, the cached value is returned, and not re-evaluated. """ @wraps(func) def callee(*args, **kwargs): key = _get_function_cache_entry(args, kwargs) try: value = func._cache[key] except (KeyError, AttributeError): value = func(*args, **kwargs) if not hasattr(func, '_cache'): setattr(func, '_cache', {}) func._cache[key] = value return value callee._cache = func._cache = dict() callee.__cached_method__ = True return callee def clear_cache(self): if hasattr(self, '_cache'): getattr(self, '_cache').clear() def clear_cached_entry(self, *args, **kwargs): if isinstance(self, MethodType) and getattr(self, '__cached_method__', False): method = self self = getattr(method, 'im_self', getattr(method, '__self__', None)) if self is None: return key = _get_instancemethod_cache_entry(method.__method_id__, *args, **kwargs) elif isinstance(self, FunctionType) and getattr(self, '__cached_method__', False): key = _get_function_cache_entry(args, kwargs) else: return _ = getattr(self, '_cache', {}).pop(key, None) def populate_cache(self, attributes_to_skip=[]): """this method attempts to get all the lazy cached properties and methods There are two special cases: - Some attributes may not be available and raises exceptions. If you wish to skip these, pass them in the attributes_to_skip list - The calling of cached methods is done without any arguments, and catches TypeError exceptions for the case a cached method requires arguments. The exception is logged.""" from inspect import getmembers for key, value in getmembers(self): if key in attributes_to_skip: continue if hasattr(value, "__cached_method__"): logger.debug("getting attribute %s from %s", repr(key), repr(self)) try: _ = value() except TypeError as e: logger.exception(e) class LazyImmutableDict(object): """ Use this object when you have a list of keys but fetching the values is expensive, and you want to do it in a lazy fasion""" def __init__(self, dict): self._dict = dict def __getitem__(self, key): value = self._dict[key] if value is None: value = self._dict[key] = self._create_value(key) return value def keys(self): return self._dict.keys() def __contains__(self, key): return self._dict.__contains__(key) def has_key(self, key): return key in self._dict def __len__(self): return len(self._dict) def _create_value(self, key): raise NotImplementedError() class CacheData(dict): def __init__(self): super(CacheData, self).__init__() self._is_valid = set() def __getitem__(self, key): if key not in self._is_valid: logger.debug("cache found invalidate., updating cache for {0}".format(key)) raise KeyError return dict.__getitem__(self, key) def __setitem__(self, key, value): ret_val = dict.__setitem__(self, key, value) self._is_valid.add(key) return ret_val def invalidate(self): logger.debug("Invalidate cache") self._is_valid = set() class TimerCacheData(CacheData): def __init__(self, poll_time): super(TimerCacheData, self).__init__() self.poll_time = poll_time def __getitem__(self, key): next_poll_time, value = CacheData.__getitem__(self, key) if time.time() > next_poll_time: raise KeyError return value def __setitem__(self, key, value): next_poll_time = time.time() + self.poll_time ret_val = CacheData.__setitem__(self, key, (next_poll_time, value)) return ret_val

f741d28c120ea874d240f15469308faf34286a81

py

Python

src/radical/ensemblemd/kernel_plugins/misc/diff.py

chemlove/radical.ensemblemd

0ec4b127760d2fee88d4eae1768fecec4bdd6b21

src/radical/ensemblemd/kernel_plugins/misc/diff.py

chemlove/radical.ensemblemd

0ec4b127760d2fee88d4eae1768fecec4bdd6b21

src/radical/ensemblemd/kernel_plugins/misc/diff.py

chemlove/radical.ensemblemd

0ec4b127760d2fee88d4eae1768fecec4bdd6b21

#!/usr/bin/env python """A kernel that compares two ASCII files and outputs the differences in a detailed format. """ __author__ = "Ioannis Paraskevakos <i.paraskev@rutgers.edu>" __copyright__ = "Copyright 2014, http://radical.rutgers.edu" __license__ = "MIT" from copy import deepcopy from radical.ensemblemd.exceptions import ArgumentError from radical.ensemblemd.exceptions import NoKernelConfigurationError from radical.ensemblemd.kernel_plugins.kernel_base import KernelBase # ------------------------------------------------------------------------------ # _KERNEL_INFO = { "name": "misc.diff", "description": "Counts the differences between two ASCII files.", "arguments": {"--inputfile1=": { "mandatory": True, "description": "The first input ASCII file." }, "--inputfile2=": { "mandatory": True, "description": "The second input ASCII file." }, "--outputfile=": { "mandatory": True, "description": "The output file containing the difference count." }, }, "machine_configs": { "*": { "environment" : None, "pre_exec" : None, "executable" : "diff", "uses_mpi" : False } } } # ------------------------------------------------------------------------------ # class Kernel(KernelBase): # -------------------------------------------------------------------------- # def __init__(self): """Le constructor. """ super(Kernel, self).__init__(_KERNEL_INFO) # -------------------------------------------------------------------------- # @staticmethod def get_name(): return _KERNEL_INFO["name"] # -------------------------------------------------------------------------- # def _bind_to_resource(self, resource_key): """(PRIVATE) Implements parent class method. """ if resource_key not in _KERNEL_INFO["machine_configs"]: if "*" in _KERNEL_INFO["machine_configs"]: # Fall-back to generic resource key resource_key = "*" else: raise NoKernelConfigurationError(kernel_name=_KERNEL_INFO["name"], resource_key=resource_key) cfg = _KERNEL_INFO["machine_configs"][resource_key] executable = "/bin/bash" arguments = ['-l', '-c', 'diff -U 0 {input1} {input2} | grep ^@ | wc -l > {output}'.format( input1 = self.get_arg("--inputfile1="), input2 = self.get_arg("--inputfile2="), output = self.get_arg("--outputfile=")) ] self._executable = executable self._arguments = arguments self._environment = cfg["environment"] self._uses_mpi = cfg["uses_mpi"] self._pre_exec = None

f74252377db9d6fa8eeb07059e4b49ddfc329441

py

Python

samples/snippets/quickstart/quickstart.py

glaswasser/python-vision

706c314a86b8f35c313bb3e907ae84317dca1a0b

samples/snippets/quickstart/quickstart.py

glaswasser/python-vision

706c314a86b8f35c313bb3e907ae84317dca1a0b

samples/snippets/quickstart/quickstart.py

glaswasser/python-vision

706c314a86b8f35c313bb3e907ae84317dca1a0b

#!/usr/bin/env python # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. #$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\heinz\OneDrive - Yagora GmbH\Heinz Yagora privat\privat\computer_vision\python-vision\FMCG-Vision-71451fde95cf.json" def run_quickstart(): # [START vision_quickstart] import io import os # Imports the Google Cloud client library # [START vision_python_migration_import] from google.cloud import vision # [END vision_python_migration_import] # Instantiates a client # [START vision_python_migration_client] client = vision.ImageAnnotatorClient() # [END vision_python_migration_client] # The name of the image file to annotate file_name = os.path.abspath('resources/wakeupcat.jpg') # Loads the image into memory with io.open(file_name, 'rb') as image_file: content = image_file.read() image = vision.Image(content=content) # Performs label detection on the image file response = client.label_detection(image=image) labels = response.label_annotations print('Labels:') for label in labels: print(label.description) # [END vision_quickstart] if __name__ == '__main__': run_quickstart()

f7425d36fe0f6897968f289c5528c4b52be383e4

py

Python

utils/check_repo.py

slowy07/transformers

7223844df9738719ee335428a326cd712f506806

2021-08-10T01:10:44.000Z

2022-01-20T15:23:49.000Z

utils/check_repo.py

4nalog/transformers

76cadb7943c8492ec481f4f3925e9e8793a32c9d

2020-03-21T21:38:47.000Z

2020-03-21T21:38:50.000Z

utils/check_repo.py

4nalog/transformers

76cadb7943c8492ec481f4f3925e9e8793a32c9d

2021-04-02T20:42:10.000Z

2021-04-02T20:42:10.000Z

# coding=utf-8 # Copyright 2020 The HuggingFace Inc. team. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import importlib import inspect import os import re import warnings from pathlib import Path from transformers import is_flax_available, is_tf_available, is_torch_available from transformers.file_utils import ENV_VARS_TRUE_VALUES from transformers.models.auto import get_values # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_repo.py PATH_TO_TRANSFORMERS = "src/transformers" PATH_TO_TESTS = "tests" PATH_TO_DOC = "docs/source" # Update this list with models that are supposed to be private. PRIVATE_MODELS = [ "DPRSpanPredictor", "T5Stack", "TFDPRSpanPredictor", ] # Update this list for models that are not tested with a comment explaining the reason it should not be. # Being in this list is an exception and should **not** be the rule. IGNORE_NON_TESTED = PRIVATE_MODELS.copy() + [ # models to ignore for not tested "BigBirdPegasusEncoder", # Building part of bigger (tested) model. "BigBirdPegasusDecoder", # Building part of bigger (tested) model. "BigBirdPegasusDecoderWrapper", # Building part of bigger (tested) model. "DetrEncoder", # Building part of bigger (tested) model. "DetrDecoder", # Building part of bigger (tested) model. "DetrDecoderWrapper", # Building part of bigger (tested) model. "M2M100Encoder", # Building part of bigger (tested) model. "M2M100Decoder", # Building part of bigger (tested) model. "Speech2TextEncoder", # Building part of bigger (tested) model. "Speech2TextDecoder", # Building part of bigger (tested) model. "LEDEncoder", # Building part of bigger (tested) model. "LEDDecoder", # Building part of bigger (tested) model. "BartDecoderWrapper", # Building part of bigger (tested) model. "BartEncoder", # Building part of bigger (tested) model. "BertLMHeadModel", # Needs to be setup as decoder. "BlenderbotSmallEncoder", # Building part of bigger (tested) model. "BlenderbotSmallDecoderWrapper", # Building part of bigger (tested) model. "BlenderbotEncoder", # Building part of bigger (tested) model. "BlenderbotDecoderWrapper", # Building part of bigger (tested) model. "MBartEncoder", # Building part of bigger (tested) model. "MBartDecoderWrapper", # Building part of bigger (tested) model. "MegatronBertLMHeadModel", # Building part of bigger (tested) model. "MegatronBertEncoder", # Building part of bigger (tested) model. "MegatronBertDecoder", # Building part of bigger (tested) model. "MegatronBertDecoderWrapper", # Building part of bigger (tested) model. "PegasusEncoder", # Building part of bigger (tested) model. "PegasusDecoderWrapper", # Building part of bigger (tested) model. "DPREncoder", # Building part of bigger (tested) model. "ProphetNetDecoderWrapper", # Building part of bigger (tested) model. "ReformerForMaskedLM", # Needs to be setup as decoder. "TFDPREncoder", # Building part of bigger (tested) model. "TFElectraMainLayer", # Building part of bigger (tested) model (should it be a TFPreTrainedModel ?) "TFRobertaForMultipleChoice", # TODO: fix "SeparableConv1D", # Building part of bigger (tested) model. ] # Update this list with test files that don't have a tester with a `all_model_classes` variable and which don't # trigger the common tests. TEST_FILES_WITH_NO_COMMON_TESTS = [ "test_modeling_camembert.py", "test_modeling_flax_mt5.py", "test_modeling_mbart.py", "test_modeling_mt5.py", "test_modeling_pegasus.py", "test_modeling_tf_camembert.py", "test_modeling_tf_mt5.py", "test_modeling_tf_xlm_roberta.py", "test_modeling_xlm_prophetnet.py", "test_modeling_xlm_roberta.py", ] # Update this list for models that are not in any of the auto MODEL_XXX_MAPPING. Being in this list is an exception and # should **not** be the rule. IGNORE_NON_AUTO_CONFIGURED = PRIVATE_MODELS.copy() + [ # models to ignore for model xxx mapping "BeitForMaskedImageModeling", "CLIPTextModel", "CLIPVisionModel", "FlaxCLIPTextModel", "FlaxCLIPVisionModel", "FlaxWav2Vec2ForCTC", "DetrForSegmentation", "DPRReader", "FlaubertForQuestionAnswering", "GPT2DoubleHeadsModel", "LukeForEntityClassification", "LukeForEntityPairClassification", "LukeForEntitySpanClassification", "OpenAIGPTDoubleHeadsModel", "RagModel", "RagSequenceForGeneration", "RagTokenForGeneration", "TFDPRReader", "TFGPT2DoubleHeadsModel", "TFOpenAIGPTDoubleHeadsModel", "TFRagModel", "TFRagSequenceForGeneration", "TFRagTokenForGeneration", "Wav2Vec2ForCTC", "HubertForCTC", "XLMForQuestionAnswering", "XLNetForQuestionAnswering", "SeparableConv1D", "VisualBertForRegionToPhraseAlignment", "VisualBertForVisualReasoning", "VisualBertForQuestionAnswering", "VisualBertForMultipleChoice", "TFWav2Vec2ForCTC", "TFHubertForCTC", ] # This is to make sure the transformers module imported is the one in the repo. spec = importlib.util.spec_from_file_location( "transformers", os.path.join(PATH_TO_TRANSFORMERS, "__init__.py"), submodule_search_locations=[PATH_TO_TRANSFORMERS], ) transformers = spec.loader.load_module() # If some modeling modules should be ignored for all checks, they should be added in the nested list # _ignore_modules of this function. def get_model_modules(): """Get the model modules inside the transformers library.""" _ignore_modules = [ "modeling_auto", "modeling_encoder_decoder", "modeling_marian", "modeling_mmbt", "modeling_outputs", "modeling_retribert", "modeling_utils", "modeling_flax_auto", "modeling_flax_utils", "modeling_transfo_xl_utilities", "modeling_tf_auto", "modeling_tf_outputs", "modeling_tf_pytorch_utils", "modeling_tf_utils", "modeling_tf_transfo_xl_utilities", ] modules = [] for model in dir(transformers.models): # There are some magic dunder attributes in the dir, we ignore them if not model.startswith("__"): model_module = getattr(transformers.models, model) for submodule in dir(model_module): if submodule.startswith("modeling") and submodule not in _ignore_modules: modeling_module = getattr(model_module, submodule) if inspect.ismodule(modeling_module): modules.append(modeling_module) return modules def get_models(module, include_pretrained=False): """Get the objects in module that are models.""" models = [] model_classes = (transformers.PreTrainedModel, transformers.TFPreTrainedModel, transformers.FlaxPreTrainedModel) for attr_name in dir(module): if not include_pretrained and ("Pretrained" in attr_name or "PreTrained" in attr_name): continue attr = getattr(module, attr_name) if isinstance(attr, type) and issubclass(attr, model_classes) and attr.__module__ == module.__name__: models.append((attr_name, attr)) return models def is_a_private_model(model): """Returns True if the model should not be in the main init.""" if model in PRIVATE_MODELS: return True # Wrapper, Encoder and Decoder are all privates if model.endswith("Wrapper"): return True if model.endswith("Encoder"): return True if model.endswith("Decoder"): return True return False def check_models_are_in_init(): """Checks all models defined in the library are in the main init.""" models_not_in_init = [] dir_transformers = dir(transformers) for module in get_model_modules(): models_not_in_init += [ model[0] for model in get_models(module, include_pretrained=True) if model[0] not in dir_transformers ] # Remove private models models_not_in_init = [model for model in models_not_in_init if not is_a_private_model(model)] if len(models_not_in_init) > 0: raise Exception(f"The following models should be in the main init: {','.join(models_not_in_init)}.") # If some test_modeling files should be ignored when checking models are all tested, they should be added in the # nested list _ignore_files of this function. def get_model_test_files(): """Get the model test files.""" _ignore_files = [ "test_modeling_common", "test_modeling_encoder_decoder", "test_modeling_marian", "test_modeling_tf_common", ] test_files = [] for filename in os.listdir(PATH_TO_TESTS): if ( os.path.isfile(f"{PATH_TO_TESTS}/{filename}") and filename.startswith("test_modeling") and not os.path.splitext(filename)[0] in _ignore_files ): test_files.append(filename) return test_files # This is a bit hacky but I didn't find a way to import the test_file as a module and read inside the tester class # for the all_model_classes variable. def find_tested_models(test_file): """Parse the content of test_file to detect what's in all_model_classes""" # This is a bit hacky but I didn't find a way to import the test_file as a module and read inside the class with open(os.path.join(PATH_TO_TESTS, test_file), "r", encoding="utf-8", newline="\n") as f: content = f.read() all_models = re.findall(r"all_model_classes\s+=\s+\(\s*\(([^\)]*)\)", content) # Check with one less parenthesis as well all_models += re.findall(r"all_model_classes\s+=\s+\(([^\)]*)\)", content) if len(all_models) > 0: model_tested = [] for entry in all_models: for line in entry.split(","): name = line.strip() if len(name) > 0: model_tested.append(name) return model_tested def check_models_are_tested(module, test_file): """Check models defined in module are tested in test_file.""" # XxxPreTrainedModel are not tested defined_models = get_models(module) tested_models = find_tested_models(test_file) if tested_models is None: if test_file in TEST_FILES_WITH_NO_COMMON_TESTS: return return [ f"{test_file} should define `all_model_classes` to apply common tests to the models it tests. " + "If this intentional, add the test filename to `TEST_FILES_WITH_NO_COMMON_TESTS` in the file " + "`utils/check_repo.py`." ] failures = [] for model_name, _ in defined_models: if model_name not in tested_models and model_name not in IGNORE_NON_TESTED: failures.append( f"{model_name} is defined in {module.__name__} but is not tested in " + f"{os.path.join(PATH_TO_TESTS, test_file)}. Add it to the all_model_classes in that file." + "If common tests should not applied to that model, add its name to `IGNORE_NON_TESTED`" + "in the file `utils/check_repo.py`." ) return failures def check_all_models_are_tested(): """Check all models are properly tested.""" modules = get_model_modules() test_files = get_model_test_files() failures = [] for module in modules: test_file = f"test_{module.__name__.split('.')[-1]}.py" if test_file not in test_files: failures.append(f"{module.__name__} does not have its corresponding test file {test_file}.") new_failures = check_models_are_tested(module, test_file) if new_failures is not None: failures += new_failures if len(failures) > 0: raise Exception(f"There were {len(failures)} failures:\n" + "\n".join(failures)) def get_all_auto_configured_models(): """Return the list of all models in at least one auto class.""" result = set() # To avoid duplicates we concatenate all model classes in a set. if is_torch_available(): for attr_name in dir(transformers.models.auto.modeling_auto): if attr_name.startswith("MODEL_") and attr_name.endswith("MAPPING_NAMES"): result = result | set(get_values(getattr(transformers.models.auto.modeling_auto, attr_name))) if is_tf_available(): for attr_name in dir(transformers.models.auto.modeling_tf_auto): if attr_name.startswith("TF_MODEL_") and attr_name.endswith("MAPPING_NAMES"): result = result | set(get_values(getattr(transformers.models.auto.modeling_tf_auto, attr_name))) if is_flax_available(): for attr_name in dir(transformers.models.auto.modeling_flax_auto): if attr_name.startswith("FLAX_MODEL_") and attr_name.endswith("MAPPING_NAMES"): result = result | set(get_values(getattr(transformers.models.auto.modeling_flax_auto, attr_name))) return [cls for cls in result] def ignore_unautoclassed(model_name): """Rules to determine if `name` should be in an auto class.""" # Special white list if model_name in IGNORE_NON_AUTO_CONFIGURED: return True # Encoder and Decoder should be ignored if "Encoder" in model_name or "Decoder" in model_name: return True return False def check_models_are_auto_configured(module, all_auto_models): """Check models defined in module are each in an auto class.""" defined_models = get_models(module) failures = [] for model_name, _ in defined_models: if model_name not in all_auto_models and not ignore_unautoclassed(model_name): failures.append( f"{model_name} is defined in {module.__name__} but is not present in any of the auto mapping. " "If that is intended behavior, add its name to `IGNORE_NON_AUTO_CONFIGURED` in the file " "`utils/check_repo.py`." ) return failures def check_all_models_are_auto_configured(): """Check all models are each in an auto class.""" missing_backends = [] if not is_torch_available(): missing_backends.append("PyTorch") if not is_tf_available(): missing_backends.append("TensorFlow") if not is_flax_available(): missing_backends.append("Flax") if len(missing_backends) > 0: missing = ", ".join(missing_backends) if os.getenv("TRANSFORMERS_IS_CI", "").upper() in ENV_VARS_TRUE_VALUES: raise Exception( "Full quality checks require all backends to be installed (with `pip install -e .[dev]` in the " f"Transformers repo, the following are missing: {missing}." ) else: warnings.warn( "Full quality checks require all backends to be installed (with `pip install -e .[dev]` in the " f"Transformers repo, the following are missing: {missing}. While it's probably fine as long as you " "didn't make any change in one of those backends modeling files, you should probably execute the " "command above to be on the safe side." ) modules = get_model_modules() all_auto_models = get_all_auto_configured_models() failures = [] for module in modules: new_failures = check_models_are_auto_configured(module, all_auto_models) if new_failures is not None: failures += new_failures if len(failures) > 0: raise Exception(f"There were {len(failures)} failures:\n" + "\n".join(failures)) _re_decorator = re.compile(r"^\s*@(\S+)\s+$") def check_decorator_order(filename): """Check that in the test file `filename` the slow decorator is always last.""" with open(filename, "r", encoding="utf-8", newline="\n") as f: lines = f.readlines() decorator_before = None errors = [] for i, line in enumerate(lines): search = _re_decorator.search(line) if search is not None: decorator_name = search.groups()[0] if decorator_before is not None and decorator_name.startswith("parameterized"): errors.append(i) decorator_before = decorator_name elif decorator_before is not None: decorator_before = None return errors def check_all_decorator_order(): """Check that in all test files, the slow decorator is always last.""" errors = [] for fname in os.listdir(PATH_TO_TESTS): if fname.endswith(".py"): filename = os.path.join(PATH_TO_TESTS, fname) new_errors = check_decorator_order(filename) errors += [f"- {filename}, line {i}" for i in new_errors] if len(errors) > 0: msg = "\n".join(errors) raise ValueError( f"The parameterized decorator (and its variants) should always be first, but this is not the case in the following files:\n{msg}" ) def find_all_documented_objects(): """Parse the content of all doc files to detect which classes and functions it documents""" documented_obj = [] for doc_file in Path(PATH_TO_DOC).glob("**/*.rst"): with open(doc_file, "r", encoding="utf-8", newline="\n") as f: content = f.read() raw_doc_objs = re.findall(r"(?:autoclass|autofunction):: transformers.(\S+)\s+", content) documented_obj += [obj.split(".")[-1] for obj in raw_doc_objs] return documented_obj # One good reason for not being documented is to be deprecated. Put in this list deprecated objects. DEPRECATED_OBJECTS = [ "AutoModelWithLMHead", "BartPretrainedModel", "DataCollator", "DataCollatorForSOP", "GlueDataset", "GlueDataTrainingArguments", "LineByLineTextDataset", "LineByLineWithRefDataset", "LineByLineWithSOPTextDataset", "PretrainedBartModel", "PretrainedFSMTModel", "SingleSentenceClassificationProcessor", "SquadDataTrainingArguments", "SquadDataset", "SquadExample", "SquadFeatures", "SquadV1Processor", "SquadV2Processor", "TFAutoModelWithLMHead", "TFBartPretrainedModel", "TextDataset", "TextDatasetForNextSentencePrediction", "Wav2Vec2ForMaskedLM", "Wav2Vec2Tokenizer", "glue_compute_metrics", "glue_convert_examples_to_features", "glue_output_modes", "glue_processors", "glue_tasks_num_labels", "squad_convert_examples_to_features", "xnli_compute_metrics", "xnli_output_modes", "xnli_processors", "xnli_tasks_num_labels", ] # Exceptionally, some objects should not be documented after all rules passed. # ONLY PUT SOMETHING IN THIS LIST AS A LAST RESORT! UNDOCUMENTED_OBJECTS = [ "AddedToken", # This is a tokenizers class. "BasicTokenizer", # Internal, should never have been in the main init. "CharacterTokenizer", # Internal, should never have been in the main init. "DPRPretrainedReader", # Like an Encoder. "MecabTokenizer", # Internal, should never have been in the main init. "ModelCard", # Internal type. "SqueezeBertModule", # Internal building block (should have been called SqueezeBertLayer) "TFDPRPretrainedReader", # Like an Encoder. "TransfoXLCorpus", # Internal type. "WordpieceTokenizer", # Internal, should never have been in the main init. "absl", # External module "add_end_docstrings", # Internal, should never have been in the main init. "add_start_docstrings", # Internal, should never have been in the main init. "cached_path", # Internal used for downloading models. "convert_tf_weight_name_to_pt_weight_name", # Internal used to convert model weights "logger", # Internal logger "logging", # External module "requires_backends", # Internal function ] # This list should be empty. Objects in it should get their own doc page. SHOULD_HAVE_THEIR_OWN_PAGE = [ # Benchmarks "PyTorchBenchmark", "PyTorchBenchmarkArguments", "TensorFlowBenchmark", "TensorFlowBenchmarkArguments", ] def ignore_undocumented(name): """Rules to determine if `name` should be undocumented.""" # NOT DOCUMENTED ON PURPOSE. # Constants uppercase are not documented. if name.isupper(): return True # PreTrainedModels / Encoders / Decoders / Layers / Embeddings / Attention are not documented. if ( name.endswith("PreTrainedModel") or name.endswith("Decoder") or name.endswith("Encoder") or name.endswith("Layer") or name.endswith("Embeddings") or name.endswith("Attention") ): return True # Submodules are not documented. if os.path.isdir(os.path.join(PATH_TO_TRANSFORMERS, name)) or os.path.isfile( os.path.join(PATH_TO_TRANSFORMERS, f"{name}.py") ): return True # All load functions are not documented. if name.startswith("load_tf") or name.startswith("load_pytorch"): return True # is_xxx_available functions are not documented. if name.startswith("is_") and name.endswith("_available"): return True # Deprecated objects are not documented. if name in DEPRECATED_OBJECTS or name in UNDOCUMENTED_OBJECTS: return True # MMBT model does not really work. if name.startswith("MMBT"): return True if name in SHOULD_HAVE_THEIR_OWN_PAGE: return True return False def check_all_objects_are_documented(): """Check all models are properly documented.""" documented_objs = find_all_documented_objects() modules = transformers._modules objects = [c for c in dir(transformers) if c not in modules and not c.startswith("_")] undocumented_objs = [c for c in objects if c not in documented_objs and not ignore_undocumented(c)] if len(undocumented_objs) > 0: raise Exception( "The following objects are in the public init so should be documented:\n - " + "\n - ".join(undocumented_objs) ) def check_repo_quality(): """Check all models are properly tested and documented.""" print("Checking all models are public.") check_models_are_in_init() print("Checking all models are properly tested.") check_all_decorator_order() check_all_models_are_tested() print("Checking all objects are properly documented.") check_all_objects_are_documented() print("Checking all models are in at least one auto class.") check_all_models_are_auto_configured() if __name__ == "__main__": check_repo_quality()

f7426ea00976e99a807367df8f057a858b319b91

py

Python

example/Bayesian/More advanced examples with FE models - Sfepy/material_homogenization.py

volpatto/UQpy

acbe1d6e655e98917f56b324f019881ea9ccca82

2020-09-03T12:10:39.000Z

2020-09-03T12:10:39.000Z

example/Bayesian/More advanced examples with FE models - Sfepy/material_homogenization.py

volpatto/UQpy

acbe1d6e655e98917f56b324f019881ea9ccca82

example/Bayesian/More advanced examples with FE models - Sfepy/material_homogenization.py

volpatto/UQpy

acbe1d6e655e98917f56b324f019881ea9ccca82

2021-04-04T14:17:55.000Z

2021-04-04T14:17:55.000Z

#!/usr/bin/env python # This code was adapted from http://sfepy.org/doc-devel/mat_optim.html. from __future__ import print_function from __future__ import absolute_import import sys sys.path.append('.') import matplotlib as mlp import matplotlib.pyplot as plt from matplotlib.collections import PolyCollection from mpl_toolkits.mplot3d.art3d import Poly3DCollection, Line3DCollection import numpy as np from sfepy.base.base import Struct, output from sfepy.base.log import Log from sfepy import data_dir class MaterialSimulator(object): @staticmethod def create_app(filename, is_homog=False, **kwargs): from sfepy.base.conf import ProblemConf, get_standard_keywords from sfepy.homogenization.homogen_app import HomogenizationApp from sfepy.applications import PDESolverApp required, other = get_standard_keywords() if is_homog: required.remove('equations') conf = ProblemConf.from_file(filename, required, other, define_args=kwargs) options = Struct(output_filename_trunk=None, save_ebc=False, save_ebc_nodes=False, save_regions=False, save_regions_as_groups=False, save_field_meshes=False, solve_not=False, ) output.set_output(filename='sfepy_log.txt', quiet=True) if is_homog: app = HomogenizationApp(conf, options, 'material_opt_micro:') else: app = PDESolverApp(conf, options, 'material_opt_macro:') app.conf.opt_data = {} opts = conf.options if hasattr(opts, 'parametric_hook'): # Parametric study. parametric_hook = conf.get_function(opts.parametric_hook) app.parametrize(parametric_hook) return app def __init__(self, macro_fn, micro_fn, phis, plot_meshes_bool=False): self.macro_app = self.create_app(macro_fn, is_homog=False, is_opt=True) self.micro_app = self.create_app(micro_fn, is_homog=True, is_opt=True) self.phis = phis self.plot_meshes_bool = plot_meshes_bool @staticmethod def rotate_mat(D, angle): s = np.sin(angle) c = np.cos(angle) s2 = s**2 c2 = c**2 sc = s * c T = np.array([[c2, 0, s2, 0, 2*sc,0], [0, 1, 0, 0, 0, 0], [s2, 0, c2, 0, -2*sc, 0], [0, 0, 0, c, 0, -s], [-sc, 0, sc, 0, c2 - s2, 0], [0, 0, 0, s, 0, c]]) return np.dot(np.dot(T, D), T.T) def plot_meshes(self): # plot mesh for micro problem pb = self.micro_app.problem coors = pb.domain.mesh.coors #print(set(coors[:,2])) graph = pb.domain.mesh.get_conn(pb.domain.mesh.descs[0]) graph_slice = np.zeros((graph.shape[0], 4)) for j in range(graph.shape[0]): graph_slice[j,:] = graph[j,coors[graph[j,:],2] == 0] cells_matrix = pb.domain.regions['Ym'].get_cells() cells_fibers = pb.domain.regions['Yf'].get_cells() fig = plt.figure(figsize = (12, 5)) ax = fig.add_subplot(121) pc = PolyCollection(verts=coors[graph[cells_matrix,0:4],:2], facecolors='white', edgecolors='black') ax.add_collection(pc) pc = PolyCollection(verts=coors[graph[cells_fibers,0:4],:2], facecolors='gray', edgecolors='black') ax.add_collection(pc) ax.axis('equal') ax.set_title('2D plot of microstructure') ax = fig.add_subplot(122, projection='3d') for e in range(graph.shape[0]): if e in cells_fibers: color = 'gray' else: color = 'white' tupleList = coors[graph[e,:],:] vertices = [[0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 5, 4], [1, 2, 6, 5], [2, 3, 7, 6], [3, 0, 4, 7]] verts = [[tupleList[vertices[ix][iy]] for iy in range(len(vertices[0]))] for ix in range(len(vertices))] pc3d = Poly3DCollection(verts=verts, facecolors=color, edgecolors='black', linewidths=1, alpha=0.5) ax.add_collection3d(pc3d) ax.set_title('3D plot of microstructure') plt.show(fig) # plot mesh for macro problem pb = self.macro_app.problem coors = pb.domain.mesh.coors graph = pb.domain.mesh.get_conn(pb.domain.mesh.descs[0]) fig2 = plt.figure(figsize=(5,6)) ax = fig2.add_subplot(111, projection='3d') for e in range(graph.shape[0]): tupleList = coors[graph[e,:],:] vertices = [[0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 5, 4], [1, 2, 6, 5], [2, 3, 7, 6], [3, 0, 4, 7]] verts = [[tupleList[vertices[ix][iy]] for iy in range(len(vertices[0]))] for ix in range(len(vertices))] pc3d = Poly3DCollection(verts=verts, facecolors='white', edgecolors='black', linewidths=1, alpha=0.5) ax.add_collection3d(pc3d) ax.set_xlim3d(-0.03, 0.03) ax.set_ylim3d(-0.01, 0.01) ax.set_zlim3d(-0.01, 0.1) ax.set_title('3D plot of macro system') plt.show(fig2) return None def mat_eval(self, x): mic_od = self.micro_app.conf.opt_data mac_od = self.macro_app.conf.opt_data mic_od['coefs'] = {} mic_od['mat_params'] = x_norm2real(x) self.micro_app() D = mic_od['D_homog'] comp_k = [] for phi in self.phis: #print('phi = %d' % phi) mac_od['D_homog'] = self.rotate_mat(D, np.deg2rad(phi)) self.macro_app() comp_k.append(mac_od['k']) # added by Audrey: get a plot of a slice of the mesh if self.plot_meshes_bool: self.plot_meshes() return comp_k def bounds(): x_L = [120e9, 0.2, 2e9, 0.2] x_U = [200e9, 0.45, 8e9, 0.45] return x_L, x_U def x_norm2real(x): x_L, x_U = np.array(bounds()) return x * (x_U - x_L) + x_L def x_real2norm(x): x_L, x_U = np.array(bounds()) return (x - x_L) / (x_U - x_L) micro_filename = data_dir + '/examples/homogenization/' + 'homogenization_opt.py' macro_filename = data_dir + '/examples/homogenization/' + 'linear_elasticity_opt.py' def one_simulation(x0, plot_meshes_bool=False): """ This function is the main callable here: it takes in as input the parameter vector, here x0=[E_fiber, nu_fiber, E_matrix, nu_matrix], and returns the simulated output (here slope of the force-elongation curve obtained during a tensile test), to be compared with the measured data. """ x0 = x0.reshape((-1, )) phis = [0, 30, 60, 90] #exp_data = zip([0, 30, 60, 90], [1051140., 197330., 101226., 95474.]) ms = MaterialSimulator(macro_filename, micro_filename, phis, plot_meshes_bool=plot_meshes_bool) qoi = ms.mat_eval(x0) return qoi def one_simulation_2params(x0, plot_meshes_bool=False): x0 = x0.reshape((-1, )) x0 = np.array([x0[0], 0.45, x0[1], 0.]) phis = [0, 30, 60, 90] #exp_data = zip([0, 30, 60, 90], [1051140., 197330., 101226., 95474.]) ms = MaterialSimulator(macro_filename, micro_filename, phis, plot_meshes_bool=plot_meshes_bool) qoi = ms.mat_eval(x0) return qoi def one_simulation_2params_rvs(x0, plot_meshes_bool=False): x0 = x0.reshape((-1, )) x0 = np.array([x0[0], 0.45, x0[1], 0.]) phis = [0, 30, 60, 90] ms = MaterialSimulator(macro_filename, micro_filename, phis, plot_meshes_bool=plot_meshes_bool) qoi = ms.mat_eval(x0) qoi = np.tile(np.array(qoi), 100) return qoi

f7427e3e091e4b7bc43db2bc2372dfafe57fa435

py

Python

alipay/aop/api/response/AlipayFundCouponWufuLiveAcceptResponse.py

antopen/alipay-sdk-python-all

8e51c54409b9452f8d46c7bb10eea7c8f7e8d30c

2018-08-27T16:49:32.000Z

2021-12-29T04:34:12.000Z

alipay/aop/api/response/AlipayFundCouponWufuLiveAcceptResponse.py

antopen/alipay-sdk-python-all

8e51c54409b9452f8d46c7bb10eea7c8f7e8d30c

2018-09-29T06:43:00.000Z

2021-09-02T03:27:32.000Z

alipay/aop/api/response/AlipayFundCouponWufuLiveAcceptResponse.py

antopen/alipay-sdk-python-all

8e51c54409b9452f8d46c7bb10eea7c8f7e8d30c

2018-08-27T16:59:26.000Z

2022-03-25T10:08:15.000Z

#!/usr/bin/env python # -*- coding: utf-8 -*- import json from alipay.aop.api.response.AlipayResponse import AlipayResponse from alipay.aop.api.domain.CommonPrizeModelVo import CommonPrizeModelVo class AlipayFundCouponWufuLiveAcceptResponse(AlipayResponse): def __init__(self): super(AlipayFundCouponWufuLiveAcceptResponse, self).__init__() self._prize_list = None self._prized = None @property def prize_list(self): return self._prize_list @prize_list.setter def prize_list(self, value): if isinstance(value, list): self._prize_list = list() for i in value: if isinstance(i, CommonPrizeModelVo): self._prize_list.append(i) else: self._prize_list.append(CommonPrizeModelVo.from_alipay_dict(i)) @property def prized(self): return self._prized @prized.setter def prized(self, value): self._prized = value def parse_response_content(self, response_content): response = super(AlipayFundCouponWufuLiveAcceptResponse, self).parse_response_content(response_content) if 'prize_list' in response: self.prize_list = response['prize_list'] if 'prized' in response: self.prized = response['prized']

f742bfecd3ff1bea6cfcdc0bc20e45e69326710e

py

Python

tests/version_spit_check.py

XIThing/esdl-mapeditor

9f4cd4a58714ea67aeb532e88e88f0435a87dbd5

tests/version_spit_check.py

XIThing/esdl-mapeditor

9f4cd4a58714ea67aeb532e88e88f0435a87dbd5

2020-09-30T21:16:46.000Z

2021-11-08T18:54:34.000Z

tests/version_spit_check.py

XIThing/esdl-mapeditor

9f4cd4a58714ea67aeb532e88e88f0435a87dbd5

2020-09-17T12:48:57.000Z

2020-09-17T12:48:57.000Z

# This work is based on original code developed and copyrighted by TNO 2020. # Subsequent contributions are licensed to you by the developers of such code and are # made available to the Project under one or several contributor license agreements. # # This work is licensed to you under the Apache License, Version 2.0. # You may obtain a copy of the license at # # http://www.apache.org/licenses/LICENSE-2.0 # # Contributors: # TNO - Initial implementation # Manager: # TNO #version = '' #import re #m = re.match(r"\D??(\d{1,2}+)\.?(\d{1,2}+)\.?(\d+)?.*", version) # splitted = version.split('.') # major = splitted[0] if splitted[0] is not None and splitted[0] is not '' else 1 # minor = splitted[1] if len(splitted) > 1 and splitted[1] is not None else '0' # rest = ''.join(splitted[2:]) if len(splitted) > 2 else '' # # increment # try: # import re # minor = re.split(r"\D", minor)[0] # if len(splitted) > 1 and splitted[1] is not None: # minor = int(minor) + 1 # else # except ValueError: # minor = 1 # # store # version_updated = "{}.{}".format(major, minor) # if rest is not '': # version_updated = "{}.{}".format(version_updated, rest) # print(version_updated) version = 2 version = '' if version is None else str(version) try: import re splitted = re.split(r"\D", version) print(splitted) major = splitted[0] major = int(major) + 1 except ValueError: major = 1 print(str(major))

f742e8a83d8dc2b3ed20891ea8ef42174aca4a4d

py

Python

toontown/suit/DistributedGridGoon.py

LittleNed/toontown-stride

1252a8f9a8816c1810106006d09c8bdfe6ad1e57

2020-01-02T08:43:36.000Z

2020-07-05T08:59:02.000Z

toontown/suit/DistributedGridGoon.py

NoraTT/Historical-Commits-Project-Altis-Source

fe88e6d07edf418f7de6ad5b3d9ecb3d0d285179

toontown/suit/DistributedGridGoon.py

NoraTT/Historical-Commits-Project-Altis-Source

fe88e6d07edf418f7de6ad5b3d9ecb3d0d285179

2019-06-20T23:45:23.000Z

2020-10-14T20:30:15.000Z

from pandac.PandaModules import * from direct.interval.IntervalGlobal import * from toontown.battle.BattleProps import * from direct.directnotify import DirectNotifyGlobal from toontown.suit import DistributedGoon from toontown.toonbase import ToontownGlobals from toontown.coghq import MovingPlatform class DistributedGridGoon(DistributedGoon.DistributedGoon): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedGoon') def __init__(self, cr, type = 'sg'): try: self.DistributedGridGoon_initialized return except: self.DistributedGridGoon_initialized = 1 DistributedGoon.DistributedGoon.__init__(self, cr, type) def generate(self): DistributedGoon.DistributedGoon.generate(self) self.ignore(self.uniqueName('wallHit')) self.mazeWalkTrack = None def delete(self): if self.mazeWalkTrack: self.mazeWalkTrack.pause() del self.mazeWalkTrack DistributedGoon.DistributedGoon.delete(self) def setH(self, h): self.h = h def setPathPts(self, xi, yi, zi, xf, yf, zf): self.notify.debug('setPathPts') if self.mazeWalkTrack: self.mazeWalkTrack.pause() del self.mazeWalkTrack self.mazeWalkTrack = None curPos = Point3(xi, yi, zi) nextPos = Point3(xf, yf, zf) distance = Vec3(curPos - nextPos).length() duration = distance / self.velocity self.mazeWalkTrack = Sequence(Func(self.headsUp, nextPos[0], nextPos[1], nextPos[2]), LerpPosInterval(self, duration=duration, pos=nextPos, startPos=curPos), name=self.uniqueName('mazeWalkTrack')) self.mazeWalkTrack.start() def enterWalk(self, avId = None, ts = 0): pass def exitWalk(self): pass

f7430f6ac609fa063a5c93eb798b63904e75a5c0

py

Python

sdks/python/test/test_AlertingGithubBugtrackerSettings.py

Brantone/appcenter-sdks

eeb063ecf79908b6e341fb00196d2cd9dc8f3262

sdks/python/test/test_AlertingGithubBugtrackerSettings.py

Brantone/appcenter-sdks

eeb063ecf79908b6e341fb00196d2cd9dc8f3262

2019-10-23T06:38:53.000Z

2022-01-22T07:57:58.000Z

sdks/python/test/test_AlertingGithubBugtrackerSettings.py

Brantone/appcenter-sdks

eeb063ecf79908b6e341fb00196d2cd9dc8f3262

2019-10-23T06:31:05.000Z

2021-08-21T17:32:47.000Z

# coding: utf-8 """ App Center Client Microsoft Visual Studio App Center API # noqa: E501 OpenAPI spec version: preview Contact: benedetto.abbenanti@gmail.com Project Repository: https://github.com/b3nab/appcenter-sdks """ from __future__ import absolute_import import unittest import appcenter_sdk from AlertingGithubBugtrackerSettings.clsAlertingGithubBugtrackerSettings import AlertingGithubBugtrackerSettings # noqa: E501 from appcenter_sdk.rest import ApiException class TestAlertingGithubBugtrackerSettings(unittest.TestCase): """AlertingGithubBugtrackerSettings unit test stubs""" def setUp(self): pass def tearDown(self): pass def testAlertingGithubBugtrackerSettings(self): """Test AlertingGithubBugtrackerSettings""" # FIXME: construct object with mandatory attributes with example values # model = appcenter_sdk.models.clsAlertingGithubBugtrackerSettings.AlertingGithubBugtrackerSettings() # noqa: E501 pass if __name__ == '__main__': unittest.main()

f7430f9bf69f737e29287ec59200f7dbfa4334ff

py

Python

storm_kit/mpc/control/control_utils.py

rgap/storm

5f477d6fa58c6c1ec8d8e2b57c3b21844cae17ac

storm_kit/mpc/control/control_utils.py

rgap/storm

5f477d6fa58c6c1ec8d8e2b57c3b21844cae17ac

storm_kit/mpc/control/control_utils.py

rgap/storm

5f477d6fa58c6c1ec8d8e2b57c3b21844cae17ac

# # MIT License # # Copyright (c) 2020-2021 NVIDIA CORPORATION. # # 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 math import numpy as np import torch from torch.distributions.multivariate_normal import MultivariateNormal import ghalton def scale_ctrl(ctrl, action_lows, action_highs, squash_fn='clamp'): if len(ctrl.shape) == 1: ctrl = ctrl[np.newaxis, :, np.newaxis] act_half_range = (action_highs - action_lows) / 2.0 act_mid_range = (action_highs + action_lows) / 2.0 if squash_fn == 'clamp': # ctrl = torch.clamp(ctrl, action_lows[0], action_highs[0]) ctrl = torch.max(torch.min(ctrl, action_highs), action_lows) return ctrl elif squash_fn == 'clamp_rescale': ctrl = torch.clamp(ctrl, -1.0, 1.0) elif squash_fn == 'tanh': ctrl = torch.tanh(ctrl) elif squash_fn == 'identity': return ctrl return act_mid_range.unsqueeze(0) + ctrl * act_half_range.unsqueeze(0) ####################### ## STOMP Covariance ## ####################### def get_stomp_cov(horizon, d_action, tensor_args={'device':torch.device('cpu'),'dtype':torch.float32}, cov_mode='vel', RETURN_R=False): """ Computes the covariance matrix following STOMP motion planner Coefficients from here: https://en.wikipedia.org/wiki/Finite_difference_coefficient More info here: https://github.com/ros-industrial/stomp_ros/blob/7fe40fbe6ad446459d8d4889916c64e276dbf882/stomp_core/src/utils.cpp#L36 """ acc_fd_array = [0,-1 / 12, 4 / 3, -5 / 2, 4 / 3, -1 / 12, 0] #acc_fd_array = [1/90, -3/20, 3/2, -49/18, 3/2 , -3/20, 1/90 ] #jerk_fd_array = [0, 1 / 12.0, -17 / 12.0, 46 / 12.0, -46 / 12.0, 17 / 12.0, -1 / 12.0] jerk_fd_array = [1 / 8.0, -1, 13/8, 0 , -13/8, 1, -1/8] #snap_fd_array = [-1/6, 2.0, -13/2, 28/3, -13/2, 2, -1/6] snap_fd_array = [0, 1, -4, 6, -4, 1, 0] #vel_fd_array = [0, 1.0/12.0 , -2.0/3.0 , 0 , 2.0/3.0 , -1.0/12.0 , 0 ] vel_fd_array = [0, 0 , 1, -2 , 1,0, 0 ] fd_array = acc_fd_array A = torch.zeros((d_action * horizon, d_action * horizon), device=tensor_args['device'],dtype=torch.float64) if(cov_mode == 'vel'): for k in range(d_action): for i in range(0, horizon): for j in range(-3,4): #print(j) index = i + j if(index < 0): index = 0 continue if(index >= horizon): index = horizon - 1 continue A[k * horizon + i,k * horizon + index] = fd_array[j + 3] elif(cov_mode == 'acc'): for k in range(d_action): for i in range(0, horizon): for j in range(-3,4): #print(j) index = i + j if(index < 0): index = 0 continue if(index >= horizon): index = horizon - 1 continue if(index >= horizon/2): #print(k * horizon + index - horizon//2) A[k * horizon + i,k * horizon - index - horizon//2 -1] = fd_array[j + 3] #* float((horizon-index) / horizon) else: A[k * horizon + i,k * horizon + index] = fd_array[j + 3] #* float(index/horizon) #plt.imshow(A) #plt.show() R = torch.matmul(A.transpose(-2,-1), A) #print(R[:horizon, :horizon]) #plt.imshow(R) #plt.show() #print(R) #print(torch.det(R)) cov = torch.inverse(R) cov = cov / torch.max(torch.abs(cov)) #plt.imshow(cov) #plt.show() # also compute the cholesky decomposition: scale_tril = torch.zeros((d_action * horizon, d_action * horizon), **tensor_args) scale_tril = torch.linalg.cholesky(cov) ''' k = 0 act_cov_matrix = cov[k * horizon:k * horizon + horizon, k * horizon:k * horizon + horizon] print(act_cov_matrix.shape) print(torch.det(act_cov_matrix)) local_cholesky = matrix_cholesky(act_cov_matrix) for k in range(d_action): scale_tril[k * horizon:k * horizon + horizon,k * horizon:k * horizon + horizon] = local_cholesky ''' cov = cov.to(**tensor_args) scale_tril = scale_tril.to(**tensor_args) #* 0.1 scale_tril = scale_tril / torch.max(scale_tril) if(RETURN_R): return cov, scale_tril, R return cov, scale_tril ####################### ## Gaussian Sampling ## ####################### def generate_noise(cov, shape, base_seed, filter_coeffs=None, device=torch.device('cpu')): """ Generate correlated Gaussian samples using autoregressive process """ torch.manual_seed(base_seed) beta_0, beta_1, beta_2 = filter_coeffs N = cov.shape[0] m = MultivariateNormal(loc=torch.zeros(N).to(device), covariance_matrix=cov) eps = m.sample(sample_shape=shape) # eps = np.random.multivariate_normal(mean=np.zeros((N,)), cov = cov, size=shape) if filter_coeffs is not None: for i in range(2, eps.shape[1]): eps[:,i,:] = beta_0*eps[:,i,:] + beta_1*eps[:,i-1,:] + beta_2*eps[:,i-2,:] return eps def generate_noise_np(cov, shape, base_seed, filter_coeffs=None): """ Generate correlated noisy samples using autoregressive process """ np.random.seed(base_seed) beta_0, beta_1, beta_2 = filter_coeffs N = cov.shape[0] eps = np.random.multivariate_normal(mean=np.zeros((N,)), cov = cov, size=shape) if filter_coeffs is not None: for i in range(2, eps.shape[1]): eps[:,i,:] = beta_0*eps[:,i,:] + beta_1*eps[:,i-1,:] + beta_2*eps[:,i-2,:] return eps ########################### ## Quasi-Random Sampling ## ########################### def generate_prime_numbers(num): def is_prime(n): for j in range(2, ((n //2) + 1),1): if n % j == 0: return False return True primes = [0] * num #torch.zeros(num, device=device) primes[0] = 2 curr_num = 1 for i in range(1, num): while True: curr_num += 2 if is_prime(curr_num): primes[i] = curr_num break return primes def generate_van_der_corput_sample(idx, base): f, r = 1.0, 0 while idx > 0: f /= base*1.0 r += f * (idx % base) idx = idx // base return r def generate_van_der_corput_samples_batch(idx_batch, base): inp_device = idx_batch.device batch_size = idx_batch.shape[0] f = 1.0 #torch.ones(batch_size, device=inp_device) r = torch.zeros(batch_size, device=inp_device) while torch.any(idx_batch > 0): f /= base*1.0 r += f * (idx_batch % base) #* (idx_batch > 0) idx_batch = idx_batch // base return r # def generate_van_der_corput_samples_batch_2(idx_batch, bases): # inp_device = idx_batch.device # batch_size = idx_batch.shape[0] # f = torch.ones(batch_size, device=inp_device) # r = torch.zeros(batch_size, device=inp_device) # while torch.any(idx_batch > 0): # f /= bases*1.0 # r += f * (idx_batch % base) #* (idx_batch > 0) # idx_batch = idx_batch // base # return r def generate_halton_samples(num_samples, ndims, bases=None, use_ghalton=True, seed_val=123, device=torch.device('cpu'), float_dtype=torch.float64): if not use_ghalton: samples = torch.zeros(num_samples, ndims, device=device, dtype=float_dtype) if not bases: bases = generate_prime_numbers(ndims) idx_batch = torch.arange(1,num_samples+1, device=device) for dim in range(ndims): samples[:, dim] = generate_van_der_corput_samples_batch(idx_batch, bases[dim]) else: if ndims <= 100: perms = ghalton.EA_PERMS[:ndims] sequencer = ghalton.GeneralizedHalton(perms) else: sequencer = ghalton.GeneralizedHalton(ndims, seed_val) samples = torch.tensor(sequencer.get(num_samples), device=device, dtype=float_dtype) return samples def generate_gaussian_halton_samples(num_samples, ndims, bases=None, use_ghalton=True, seed_val=123, device=torch.device('cpu'), float_dtype=torch.float64): uniform_halton_samples = generate_halton_samples(num_samples, ndims, bases, use_ghalton, seed_val, device, float_dtype) gaussian_halton_samples = torch.sqrt(torch.tensor([2.0],device=device,dtype=float_dtype)) * torch.erfinv(2 * uniform_halton_samples - 1) return gaussian_halton_samples def generate_gaussian_sobol_samples(num_samples, ndims, seed_val, device=torch.device('cpu'), float_dtype=torch.float64): soboleng = torch.quasirandom.SobolEngine(dimension=ndims, scramble=True, seed=seed_val) uniform_sobol_samples = soboleng.draw(num_samples).to(device) gaussian_sobol_samples = torch.sqrt(torch.tensor([2.0],device=device,dtype=float_dtype)) * torch.erfinv(2 * uniform_sobol_samples - 1) return gaussian_sobol_samples ######################## ## Gaussian Utilities ## ######################## def gaussian_logprob(mean, cov, x, cov_type="full"): """ Calculate gaussian log prob for given input batch x Parameters ---------- mean (np.ndarray): [N x num_samples] batch of means cov (np.ndarray): [N x N] covariance matrix x (np.ndarray): [N x num_samples] batch of sample values Returns -------- log_prob (np.ndarray): [num_sampls] log probability of each sample """ N = cov.shape[0] if cov_type == "diagonal": cov_diag = cov.diagonal() cov_inv = np.diag(1.0 / cov_diag) cov_logdet = np.sum(np.log(cov_diag)) else: cov_logdet = np.log(np.linalg.det(cov)) cov_inv = np.linalg.inv(cov) diff = (x - mean).T mahalanobis_dist = -0.5 * np.sum((diff @ cov_inv) * diff, axis=1) const1 = -0.5 * N * np.log(2.0 * np.pi) const2 = -0.5*cov_logdet log_prob = mahalanobis_dist + const1 + const2 return log_prob def gaussian_logprobgrad(mean, cov, x, cov_type="full"): if cov_type == "diagonal": cov_inv = np.diag(1.0/cov.diagonal()) else: cov_inv = np.linalg.inv(cov) diff = (x - mean).T grad = diff @ cov_inv return grad def gaussian_entropy(cov=None, L=None): #, cov_type="full"): """ Entropy of multivariate gaussian given either covariance or cholesky decomposition of covariance """ if cov is not None: inp_device = cov.device cov_logdet = torch.log(torch.det(cov)) # print(np.linalg.det(cov.cpu().numpy())) # print(torch.det(cov)) N = cov.shape[0] else: inp_device = L.device cov_logdet = 2.0 * torch.sum(torch.log(torch.diagonal(L))) N = L.shape[0] # if cov_type == "diagonal": # cov_logdet = np.sum(np.log(cov.diagonal())) # else: # cov_logdet = np.log(np.linalg.det(cov)) term1 = 0.5 * cov_logdet # pi = torch.tensor([math.pi], device=inp_device) # pre-calculate 1.0 + torch.log(2.0*pi) = 2.837877066 term2 = 0.5 * N * 2.837877066 ent = term1 + term2 return ent.to(inp_device) def gaussian_kl(mean0, cov0, mean1, cov1, cov_type="full"): """ KL-divergence between Gaussians given mean and covariance KL(p||q) = E_{p}[log(p) - log(q)] """ N = cov0.shape[0] if cov_type == "diagonal": cov1_diag = cov1.diagonal() cov1_inv = np.diag(1.0 / cov1_diag) cov0_logdet = np.sum(np.log(cov0.diagonal())) cov1_logdet = np.sum(np.log(cov1_diag)) else: cov1_inv = np.linalg.inv(cov1) cov0_logdet = np.log(np.linalg.det(cov0)) cov1_logdet = np.log(np.linalg.det(cov1)) term1 = 0.5 * np.trace(cov1_inv @ cov0) diff = (mean1 - mean0).T mahalanobis_dist = 0.5 * np.sum((diff @ cov1_inv) * diff, axis=1) term3 = 0.5 * (-1.0*N + cov1_logdet - cov0_logdet) return term1 + mahalanobis_dist + term3 def cost_to_go(cost_seq, gamma_seq): """ Calculate (discounted) cost to go for given cost sequence """ # if torch.any(gamma_seq == 0): # return cost_seq cost_seq = gamma_seq * cost_seq # discounted cost sequence # cost_seq = torch.cumsum(cost_seq[:, ::-1], axis=-1)[:, ::-1] # cost to go (but scaled by [1 , gamma, gamma*2 and so on]) cost_seq = torch.fliplr(torch.cumsum(torch.fliplr(cost_seq), axis=-1)) # cost to go (but scaled by [1 , gamma, gamma*2 and so on]) cost_seq /= gamma_seq # un-scale it to get true discounted cost to go return cost_seq def cost_to_go_np(cost_seq, gamma_seq): """ Calculate (discounted) cost to go for given cost sequence """ # if np.any(gamma_seq == 0): # return cost_seq cost_seq = gamma_seq * cost_seq # discounted reward sequence cost_seq = np.cumsum(cost_seq[:, ::-1], axis=-1)[:, ::-1] # cost to go (but scaled by [1 , gamma, gamma*2 and so on]) cost_seq /= gamma_seq # un-scale it to get true discounted cost to go return cost_seq ############ ##Cholesky## ############ def matrix_cholesky(A): L = torch.zeros_like(A) for i in range(A.shape[-1]): for j in range(i+1): s = 0.0 for k in range(j): s = s + L[i,k] * L[j,k] L[i,j] = torch.sqrt(A[i,i] - s) if (i == j) else \ (1.0 / L[j,j] * (A[i,j] - s)) return L # Batched Cholesky decomp def batch_cholesky(A): L = torch.zeros_like(A) for i in range(A.shape[-1]): for j in range(i+1): s = 0.0 for k in range(j): s = s + L[...,i,k] * L[...,j,k] L[...,i,j] = torch.sqrt(A[...,i,i] - s) if (i == j) else \ (1.0 / L[...,j,j] * (A[...,i,j] - s)) return L

f7435cd562697e1cc976e916003e38001a1a1351

py

Python

seqio/loggers.py

ayushkumar63123/seqio

23bcb59df59798074d7d5896a131980137c69ec8

2021-04-16T00:43:10.000Z

2022-03-21T08:51:27.000Z

seqio/loggers.py

ayushkumar63123/seqio

23bcb59df59798074d7d5896a131980137c69ec8

2021-04-26T06:28:51.000Z

2022-03-28T23:55:16.000Z

seqio/loggers.py

ayushkumar63123/seqio

23bcb59df59798074d7d5896a131980137c69ec8

2021-04-27T10:28:27.000Z

2022-03-10T18:43:37.000Z

# Copyright 2021 The SeqIO Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Classes for logging evaluation metrics and inference results.""" import abc import base64 import itertools import json import os import time from typing import Any, Mapping, Optional, Sequence, Type from absl import logging import numpy as np from seqio import metrics as metrics_lib import tensorflow as tf import tensorflow_datasets as tfds class Logger(abc.ABC): """Abstract base class for logging. Attributes: output_dir: a directory to save the logging results (e.g., TensorBoard summary) as well as the evaluation results (e.g., "inputs_pretokenized", "target_pretokenize" and "prediction"). """ def __init__(self, output_dir): self.output_dir = output_dir @abc.abstractmethod def __call__(self, task_name: str, step: int, metrics: Mapping[str, metrics_lib.MetricValue], dataset: tf.data.Dataset, inferences: Mapping[str, Sequence[Any]], targets: Sequence[Any]) -> None: """Logs the metrics and inferences for each task. Args: task_name: The name of the task these datapoints are relevant to. step: The timestep to place this datapoint at. metrics: A mapping from series names to numeric datapoints to be added to that series. dataset: The Task dataset. inferences: Mapping from inference type ("predictions", "scores") to the model outputs, aligned with the dataset. targets: The postprocessed targets, aligned with the dataset. """ ... class PyLoggingLogger(Logger): """A logger that writes metrics using the standard Python log.""" def __init__(self, output_dir: str, level: int = logging.INFO): self._level = level super().__init__(output_dir) def __call__(self, task_name: str, step: int, metrics: Mapping[str, metrics_lib.MetricValue], dataset: tf.data.Dataset, inferences: Mapping[str, Sequence[Any]], targets: Sequence[Any]) -> None: del dataset del inferences del targets for metric_name, metric_value in metrics.items(): if isinstance(metric_value, metrics_lib.Scalar): strvalue = f"{metric_value.value:.3f}" elif isinstance(metric_value, metrics_lib.Text): strvalue = metric_value.textdata else: strvalue = f"unloggable type {type(metric_value)}" logging.info("%s/%s at step %d: %s", task_name, metric_name, step, strvalue) class TensorBoardLogger(Logger): """A logger that writes metrics to TensorBoard summaries.""" def __init__(self, output_dir: str): """TensorBoardLogger initializer. Args: output_dir: The base directory where all logs will be written. """ super().__init__(output_dir) self._summary_writers = {} def _get_summary_writer(self, summary_dir: str) -> tf.summary.SummaryWriter: """Get or create a summary writer for a specific task. Args: summary_dir: The task we are getting the writer for. Returns: The summary writer associated with the directory. """ if summary_dir not in self._summary_writers: self._summary_writers[summary_dir] = tf.summary.create_file_writer( summary_dir, flush_millis=120) return self._summary_writers[summary_dir] def _write_metric(self, tag: str, value: metrics_lib.MetricValue, step: int, writer: tf.summary.SummaryWriter): """Log a metric value to tensorboard, dispatched on value type.""" if isinstance(value, metrics_lib.Scalar): value: metrics_lib.Scalar = value value = float(np.array(value.value)) with writer.as_default(): tf.summary.scalar(name=tag, data=value, step=step) elif isinstance(value, metrics_lib.Image): value: metrics_lib.Image = value image = tf.convert_to_tensor(value.image) with writer.as_default(): tf.summary.image( name=tag, data=image, step=step, max_outputs=value.max_outputs) elif isinstance(value, metrics_lib.Audio): value: metrics_lib.Audio = value audio = tf.convert_to_tensor(value.audiodata, dtype=tf.float32) with writer.as_default(): tf.summary.audio( name=tag, data=audio, sample_rate=value.sample_rate, step=step, max_outputs=value.max_outputs, encoding="wav") elif isinstance(value, metrics_lib.Histogram): value: metrics_lib.Histogram = value values = np.array(value.values) with writer.as_default(): tf.summary.histogram( name=tag, data=values, step=step, buckets=value.bins) elif isinstance(value, metrics_lib.Text): value: metrics_lib.Text = value if not isinstance(value.textdata, (str, bytes)): raise ValueError("`textdata` should be of the type `str` or `bytes`.") with writer.as_default(): tf.summary.text(name=tag, data=tf.constant(value.textdata), step=step) elif isinstance(value, metrics_lib.Generic): with writer.as_default(): tf.summary.write( tag=tag, tensor=value.tensor, metadata=value.metadata, step=step) else: raise TypeError( f"Value type not understood, got '{type(value).__name__}'.") def __call__(self, task_name: str, step: int, metrics: Mapping[str, metrics_lib.MetricValue], dataset: tf.data.Dataset, inferences: Mapping[str, Sequence[Any]], targets: Sequence[Any]) -> None: """Log metrics to tensorboard. Args: task_name: The name of the task these datapoints are relevant to. step: The timestep to place this datapoint at. metrics: A mapping from series names to numeric datapoints to be added to that series. dataset: The Task dataset, which is unused by this logger. inferences: The model outputs, which are unused by this logger. targets: The postprocessed targets, which are unused by this logger. """ del dataset del inferences del targets if step is None: logging.warning("Step number for the logging session is not provided. " "A dummy value of -1 will be used.") step = -1 writer = self._get_summary_writer(os.path.join(self.output_dir, task_name)) for metric_name, metric_value in metrics.items(): # We prefix the tag with "eval/" for backward compatibility. # TODO(adarob): Find a way to remove this or make it an option. self._write_metric( tag=f"eval/{metric_name}", value=metric_value, step=step, writer=writer) writer.flush() class TensorBoardLoggerV1(Logger): """A logger that writes metrics to TensorBoard summaries in TF1.""" def __init__(self, output_dir: str): """TensorBoardLoggerV1 initializer. Args: output_dir: The base directory where all logs will be written. """ super().__init__(output_dir) self._summary_writers = {} def _get_summary_writer(self, task_name: str) -> tf.summary.SummaryWriter: """Create (if needed) and return a SummaryWriter for a given task.""" if task_name not in self._summary_writers: with tf.compat.v1.Graph().as_default(): self._summary_writers[task_name] = tf.compat.v1.summary.FileWriter( os.path.join(self.output_dir, task_name)) return self._summary_writers[task_name] def __call__(self, task_name: str, step: int, metrics: Mapping[str, metrics_lib.Scalar], dataset: tf.data.Dataset, inferences: Mapping[str, Sequence[Any]], targets: Sequence[Any]) -> None: """Log the eval results and optionally write summaries for TensorBoard. Note: This is the default implementation using tensorflow v1 operations. This only supports logging metrics of the Scalar type. Args: task_name: The name of the task these datapoints are relevant to. step: The timestep to place this datapoint at. metrics: A mapping from series names to numeric datapoints to be added to that series. dataset: The Task dataset, which is unused by this logger. inferences: The model outputs, which are unused by this logger. targets: The postprocessed targets, which are unused by this logger. """ del dataset del inferences del targets if step is None: logging.warning("Step number for the logging session is not provided. " "A dummy value of -1 will be used.") step = -1 summary_writer = self._get_summary_writer(task_name) for metric_name, metric_value in metrics.items(): if not isinstance(metric_value, metrics_lib.Scalar): raise ValueError(f"Value for metric '{metric_name}' should be of " f"type 'Scalar, got '{type(metric_value).__name__}'.") summary = tf.compat.v1.Summary() tag = f"eval/{metric_name}" logging.info("%s at step %d: %.3f", tag, step, metric_value.value) summary.value.add(tag=tag, simple_value=metric_value.value) summary_writer.add_summary(summary, step) summary_writer.flush() class TensorAndNumpyEncoder(json.JSONEncoder): """JSON Encoder to use when encoding dicts with tensors and numpy arrays.""" def __init__(self, *args, max_ndarray_size=32, **kwargs): self.max_ndarray_size = max_ndarray_size super().__init__(*args, **kwargs) def default(self, obj): if isinstance(obj, tf.Tensor): if obj.dtype == tf.bfloat16: # bfloat16 not supported, convert to float32. obj = tf.cast(obj, tf.float32) obj = obj.numpy() if isinstance(obj, np.ndarray): obj_dtype = obj.dtype if str(obj.dtype) == "bfloat16": # bfloat16 not supported, convert to float32. obj = obj.astype(np.float32) if obj.size <= self.max_ndarray_size: return obj.tolist() # Convert arrays to lists of py-native types. else: # If the ndarray is larger than allowed, return a summary string # instead of the entire array. first_five_str = str(obj.reshape([-1])[:5].tolist())[1:-1] return ( f"{type(obj).__name__}(shape={obj.shape}, dtype={obj_dtype}); " f"first: {first_five_str} ...") elif (np.issubdtype(type(obj), np.number) or np.issubdtype(type(obj), np.bool_)): return obj.item() # Convert most primitive np types to py-native types. elif hasattr(obj, "dtype") and obj.dtype == tf.bfloat16.as_numpy_dtype: return float(obj) elif isinstance(obj, bytes): # JSON doesn't support bytes. First, try to decode using utf-8 in case # it's text. Otherwise, just base64 encode the bytes. try: return obj.decode("utf-8") except UnicodeDecodeError: return base64.b64encode(obj) return json.JSONEncoder.default(self, obj) class JSONLogger(Logger): """A logger that writes metrics and model outputs to JSONL files.""" def __init__( self, output_dir: str, write_n_results: Optional[int] = None, json_encoder_cls: Type[json.JSONEncoder] = TensorAndNumpyEncoder): """JSONLogger constructor. Args: output_dir: The base directory where all logs will be written. write_n_results: number of scores/predictions to be written to the file at each step. If None, scores and predictions from all examples are written. json_encoder_cls: Class to use for serializing JSON to file. """ super().__init__(output_dir) self._write_n_results = write_n_results self._json_encoder_cls = json_encoder_cls def __call__(self, task_name: str, step: int, metrics: Mapping[str, metrics_lib.MetricValue], dataset: tf.data.Dataset, inferences: Mapping[str, Sequence[Any]], targets: Sequence[Any]) -> None: if step is None: logging.warning("Step number for the logging session is not provided. " "A dummy value of -1 will be used.") step = -1 metrics_fname = os.path.join(self.output_dir, f"{task_name}-metrics.jsonl") serializable_metrics = {} for metric_name, metric_value in metrics.items(): if isinstance(metric_value, metrics_lib.Scalar): serializable_metrics[metric_name] = metric_value.value elif isinstance(metric_value, metrics_lib.Text): serializable_metrics[metric_name] = metric_value.textdata else: logging.warning( "Skipping JSON logging of non-serializable metric '%s' of type %s.", metric_name, type(metric_value)) if metrics: logging.info("Appending metrics to %s", metrics_fname) # We simulate an atomic append for filesystems that do not suppport # mode="a". file_contents = "" if tf.io.gfile.exists(metrics_fname): with tf.io.gfile.GFile(metrics_fname, "r") as f: file_contents = f.read() with tf.io.gfile.GFile(metrics_fname + ".tmp", "w") as f: f.write(file_contents) f.write( json.dumps({ "step": step, **serializable_metrics }, cls=self._json_encoder_cls)) f.write("\n") tf.io.gfile.rename(metrics_fname + ".tmp", metrics_fname, overwrite=True) if self._write_n_results == 0: return write_tick = time.time() inferences_fname = os.path.join(self.output_dir, f"{task_name}-{step:06}.jsonl") logging.info("Writing inferences to %s", inferences_fname) with tf.io.gfile.GFile(inferences_fname, "w") as f: examples_with_scores = itertools.zip_longest( tfds.as_numpy(dataset), inferences.get("predictions", []), targets, inferences.get("scores", [])) if self._write_n_results: examples_with_scores = itertools.islice( examples_with_scores, 0, self._write_n_results) for inp, prediction, target, score in examples_with_scores: # tfds.as_numpy does not convert ragged tensors for k in inp: if isinstance(inp[k], tf.RaggedTensor): inp[k] = inp[k].numpy() json_dict = {"input": inp} # Only write `prediction` if it is JSON serializable. if prediction is not None: try: json.dumps(prediction, cls=self._json_encoder_cls) json_dict["prediction"] = prediction except TypeError: logging.warning("`prediction` is not JSON serializable", exc_info=True) # Only write `target` if it is JSON serializable. try: json.dumps(target, cls=self._json_encoder_cls) json_dict["target"] = target except TypeError: logging.warning("`target` is not JSON serializable", exc_info=True) if score is not None: json_dict["score"] = score json_str = json.dumps(json_dict, cls=self._json_encoder_cls) f.write(json_str + "\n") write_time = time.time() - write_tick logging.info("Writing completed in %02f seconds (%02f examples/sec).", write_time, len(inferences) / write_time)

f7436947b0127f7e035d1d3e1ed4f83760e00c34

py

Python

tests/python/pants_test/help/test_help_formatter.py

dturner-tw/pants

3a04f2e46bf2b8fb0a7999c09e4ffdf9057ed33f

tests/python/pants_test/help/test_help_formatter.py

dturner-tw/pants

3a04f2e46bf2b8fb0a7999c09e4ffdf9057ed33f

tests/python/pants_test/help/test_help_formatter.py

dturner-tw/pants

3a04f2e46bf2b8fb0a7999c09e4ffdf9057ed33f

2019-06-10T17:24:34.000Z

2019-06-10T17:24:34.000Z

# coding=utf-8 # Copyright 2015 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import (absolute_import, division, generators, nested_scopes, print_function, unicode_literals, with_statement) import unittest from pants.help.help_formatter import HelpFormatter from pants.help.help_info_extracter import OptionHelpInfo class OptionHelpFormatterTest(unittest.TestCase): def format_help_for_foo(self, **kwargs): ohi = OptionHelpInfo(registering_class=type(None), display_args=['--foo'], scoped_cmd_line_args=['--foo'], unscoped_cmd_line_args=['--foo'], typ=bool, fromfile=False, default=None, help='help for foo', deprecated_version=None, deprecated_message=None, deprecated_hint=None, choices=None) ohi = ohi._replace(**kwargs) lines = HelpFormatter(scope='', show_recursive=False, show_advanced=False, color=False).format_option(ohi) self.assertEquals(len(lines), 2) self.assertIn('help for foo', lines[1]) return lines[0] def test_format_help(self): line = self.format_help_for_foo(default='MYDEFAULT') self.assertEquals('--foo (default: MYDEFAULT)', line) def test_format_help_fromfile(self): line = self.format_help_for_foo(fromfile=True) self.assertEquals('--foo (@fromfile value supported) (default: None)', line) def test_suppress_advanced(self): args = ['--foo'] kwargs = {'advanced': True} lines = HelpFormatter(scope='', show_recursive=False, show_advanced=False, color=False).format_options('', '', [(args, kwargs)]) self.assertEquals(0, len(lines)) lines = HelpFormatter(scope='', show_recursive=True, show_advanced=True, color=False).format_options('', '', [(args, kwargs)]) print(lines) self.assertEquals(5, len(lines)) def test_format_help_choices(self): line = self.format_help_for_foo(typ=str, default='kiwi', choices='apple, banana, kiwi') self.assertEquals('--foo (one of: [apple, banana, kiwi] default: kiwi)', line)

f7438d9ecc8eceb41e12585b9b81484d7c841141

py

Python

pycatia/in_interfaces/files.py

Tian-Jionglu/pycatia

b315aeb3a74846f134ff6b67b3a6334b9d3905fa

2020-04-27T13:59:10.000Z

2020-04-27T13:59:10.000Z

pycatia/in_interfaces/files.py

Luanee/pycatia

ea5eef8178f73de12404561c00baf7a7ca30da59

pycatia/in_interfaces/files.py

Luanee/pycatia

ea5eef8178f73de12404561c00baf7a7ca30da59

#! usr/bin/python3.6 """ Module initially auto generated using V5Automation files from CATIA V5 R28 on 2020-06-11 12:40:47.360445 .. warning:: The notes denoted "CAA V5 Visual Basic Help" are to be used as reference only. They are there as a guide as to how the visual basic / catscript functions work and thus help debugging in pycatia. """ from pycatia.in_interfaces.file import File from pycatia.system_interfaces.collection import Collection class Files(Collection): """ .. note:: :class: toggle CAA V5 Visual Basic Help (2020-06-11 12:40:47.360445) | System.IUnknown | System.IDispatch | System.CATBaseUnknown | System.CATBaseDispatch | System.Collection | Files | | A collection of all the file objects in a folder. | It lists all the files contained in the folder. It allows to retrieve File | objects. """ def __init__(self, com_object): super().__init__(com_object, child_object=File) self.files = com_object def item(self, i_number: int) -> File: """ .. note:: :class: toggle CAA V5 Visual Basic Help (2020-06-11 12:40:47.360445)) | o Func Item(long iNumber) As File | | Returns a file using its index or its name from the file | collection. | | Parameters: | | iIndex | The index or the name of the file to retrieve from the collection | of files. As a numerics, this index is the rank of the file in the collection. | The index of the first file in the collection is 1, and the index of the last | file is Count. As a string, it is the name you assigned to the file using the | | | AnyObject.Name property. | Returns: | The retrieved file | Example: | This example retrieves in ThisFile the third file, and it ThatFile the | file named MyFile. in the TestFiles file collection. | | Dim ThisFile As File | Set ThisFile = TestFiles.Item(3) | Dim ThatFile As File | Set ThatFile = TestFiles.Item("MyFile") :param int i_number: :return: File :rtype: File """ return File(self.files.Item(i_number)) def __getitem__(self, n: int) -> File: if (n + 1) > self.count: raise StopIteration return File(self.files.item(n + 1)) def __repr__(self): return f'Files(name="{self.name}")'

f7438fb7972362af0e6a82e3fe654cfd9d62a05f

py

Python

flask_sqlite_web/sqliteFunctions.py

haibozhucloud/flask_sqlite_web

d0b407b359557bfd3cbb516d365f06c67f8d61d0

2019-01-15T06:49:34.000Z

2021-08-06T02:57:20.000Z

flask_sqlite_web/sqliteFunctions.py

haibozhucloud/flask_sqlite_web

d0b407b359557bfd3cbb516d365f06c67f8d61d0

flask_sqlite_web/sqliteFunctions.py

haibozhucloud/flask_sqlite_web

d0b407b359557bfd3cbb516d365f06c67f8d61d0

######################################### # Author : Haibo Zhu # Email : haibo.zhu@hotmail.com # created : 2018-11-06 13:38 # Last modified : 2018-11-08 14:49 # Filename : sqliteFunctions.py # Description : ######################################### import re from functools import wraps import types import sys import sqlite3 import pprint import time ''' reload(sys) sys.setdefaultencoding("utf-8") ''' def execRule(i): def do_assignment(to_func): to_func.run = i return to_func return do_assignment class rules: """ base rules applied to all modifications """ def __init__(self,colData,postData,tables,method): self.colData = colData self.postData = postData self.method = method self.methods = ['GET','POST','PUT','DELETE'] self.tables = tables if self.colData['name'] in self.postData: self.value = self.postData[self.colData['name']] else: self.value = '0' @execRule(1) def validTable(self): """ check if table is in object """ if 'table' not in self.postData or self.postData['table'] not in self.tables: raise ValueError('invalid table `%s`' % self.postData['table']) @execRule(2) def validAction(self): """ check if action is valid """ if self.method is None: raise ValueError('no method in request') elif self.method not in self.methods: raise ValueError('invalid method `%s`' % self.method) @execRule(3) def idRequired(self): """ check if id parameter passed for edit/delete functions """ if self.method == 'put' or self.method == 'delete': if 'id' not in self.postData: raise ValueError('Request must include an id') @execRule(4) def notNull(self): """ check if null value passed for not null columns """ if self.colData['name'] not in self.postData or self.value=='': if self.colData['notNull'] is 1 and self.colData['primaryKey'] is 0: raise ValueError('%s field required' % self.colData['name']) @execRule(5) def integer(self): """ check if integer for integer affinity columns """ if self.colData['dataType'].lower() in ['integer','int','tinyint','smallint','mediumint','bigint','unisgned big int','int2','int8']: try: int(self.value) except Exception as e: raise ValueError('Non integer value `%s` for field %s' % (self.value, self.colData['name']) ) @execRule(6) def real(self): """ check if float for real affinity columns """ if self.colData['dataType'].lower() in ['real','float','double','double precision']: try: float(self.value) except Exception as e: raise ValueError('Non real/float value `%s` for field %s' % (self.value, self.colData['name']) ) class sqliteAdminFunctions: """ functions for SQLite3 Admin tool """ def __init__(self,con,tables=[],extraRules=[]): self.db = con self.extraRules = extraRules self.tables = self.tableList(tables) def dict_factory(self,cursor, row): """ function to return sqlite results in dict """ d = {} for idx, col in enumerate(cursor.description): try: d[col[0]] = row[idx] except: d[col[0]] = "invalid byte" return d def tableList(self,tables): if len(tables) > 0: return tables else: c = self.db.session.execute('SELECT name FROM sqlite_master WHERE type = "table"') tables= c.fetchall() if ('sqlite_sequence',) in tables: tables.remove(('sqlite_sequence',)) return [row[0] for row in tables] def tableContents(self,table,sort,dir,offset): """ create list of tables for admin """ res = {} if table in self.tables: res['schema'] = self.tableSchemas(table) if res['schema'][0]['primaryKey'] == 1: res['primaryKey'] = res['schema'][0]['name'] c = self.db.session.execute('select count({}) as c from {}'.format(res['primaryKey'],table)) res['count'] = c.fetchone()['c'] if sort == '': sort = res['primaryKey'] l = self.db.session.execute('select * from {} order by {} {} limit {},50'.format(table,sort,dir,int(offset)*50)) res['contents'] = l.fetchall() return res else: raise ValueError('No primary key for first column in table `%s`' % table) else: raise ValueError('invalid table `%s`' % table) def tableSchemas(self,table): """ return table schemas by column """ sch = self.db.session.execute('PRAGMA table_info({})'.format(table)) sch_ls = sch return [{'name':row[1],'dataType':row[2],'notNull':row[3],'primaryKey':row[5]} for row in sch_ls] def tableCols(self, table): tb_info = self.db.session.execute('PRAGMA table_info({})'.format(table) ) sch = tb_info.fetchall() res = [] for row in sch: c = '' c += row[1] c += ' ' + row[2] if row[5] == 1: c += ' PRIMARY KEY AUTOINCREMENT' res.append(c) return res def checkValid(self,q,method): """ validate admin input """ if 'table' not in q: raise ValueError('no table value provided') elif q['table'] not in self.tables: raise ValueError('invalid table `%s`' % q['table']) else: for col in self.tableSchemas(q['table']): # iterate through rules r = rules(col,q,self.tables,method) # instantiate rules objecy if len(self.extraRules)>0: # add extra rules for i,x in enumerate(self.extraRules): x.run = 7+i def add_method(self, method, i): setattr(self.__class__, 'extraRule%d' % i, method) add_method(r,x,i) # perform rule check funcs = sorted( [ getattr(r, field) for field in dir(r) if hasattr(getattr(r, field), "run") ], key = (lambda field: field.run) ) for func in funcs: try: func() except Exception as e: raise def editTables(self,q,method): """ edit tables """ qString = '' qParams = [] # validate input self.checkValid(q,method) # create copy of request q2 = q.copy() del q2['table'] # edit ret = '' if method == 'PUT': del q2['id'] del q2['primaryKey'] qString = 'update %s set %s where %s=?' % (q['table'],', '.join("%s=?" %p for p in q2.keys()),q['primaryKey']) qParams = [v for k,v in q2.items()] qParams.append(q[q['primaryKey']]) # add elif method == 'POST': del q2['primaryKey'] qString = 'insert into %s (%s) values (%s)' % (q['table'],','.join(q2.keys()),','.join("?" for p in q2.keys()) ) qParams = [v for k,v in q2.items()] ret = '<a href="" class="alert-link">Refresh Page</a>' # delete elif method == 'DELETE': qString = 'delete from %s where %s=?' % (q['table'],q['primaryKey']) qParams = [q['id']] ret = 'Row deleted' # execute sql self.db.session.execute(qString,qParams) self.db.session.commit() return ret #检查表中是否已存在列 def checkColumn(self,col,table): sch = self.tableSchemas(table) cols = [{'col':row['name']} for row in sch] if {'col':col} in cols: return True return False def addCol(self,new_col,new_col_type,table): #增加新字段 if self.checkColumn(new_col,table): return(0) command = "ALTER TABLE {} ADD {} {};".format(table, new_col, new_col_type) res = self.db.session.execute(command) self.db.session.commit() def delRow(self, table, id): command = "delete from {} where id={}".format(table,id) self.db.session.execute(command) self.db.session.commit() def saveRow(self, row, table,id): r = [] for k,v in row.items(): r.append("{}={}".format(k,v)) command = "update {} set {} where id={}".format(table,",".join(r),id) self.db.session.execute(command) self.db.session.commit() def delCol(self, del_col, table): cols = self.tableCols(table) deleted = False for c in cols: if c.find(del_col) == 0: cols.remove(c) deleted = True break if deleted == False: return cp_cols= [row.split()[0] for row in cols] try: command = "drop table if exists 'temp'" self.db.session.execute(command) self.db.session.commit() command = "create table temp({})".format(','.join(cols)) self.db.session.execute(command) self.db.session.commit() command = "insert into {}({}) select {} from {}".format('temp', ','.join(cp_cols), ','.join(cp_cols), table) self.db.session.execute(command) self.db.session.commit() command = "drop table if exists {}".format(table) self.db.session.execute(command) self.db.session.commit() command = "alter table temp rename to {}".format(table) self.db.session.execute(command) self.db.session.commit() except self.db.Error as ex: print(" !!! Exception:".format(ex)) def addRow(self, table, row): values = [] keys = [] for k,v in row.items(): values.append(v) keys.append(k) command = "insert into {}({}) values({})".format(table, ",".join(keys),",".join(values)) self.db.session.execute(command) self.db.session.commit()

f743b9c07354f5c2f9fa0aee2bcab50a14abbd00

py

Python

src/lyxnotebook/run_lyxnotebook.py

abarker/lyxNotebook

c458b21e1b183b94172414e14dea671e1f3d4b22

2015-07-16T13:39:04.000Z

2022-02-14T15:36:10.000Z

src/lyxnotebook/run_lyxnotebook.py

abarker/lyxNotebook

c458b21e1b183b94172414e14dea671e1f3d4b22

2020-03-11T00:33:50.000Z

2020-05-21T22:05:13.000Z

src/lyxnotebook/run_lyxnotebook.py

abarker/lyxNotebook

c458b21e1b183b94172414e14dea671e1f3d4b22

2015-07-16T13:39:06.000Z

2020-04-15T19:17:45.000Z

#! /usr/bin/python """ ========================================================================= This file is part of LyX Notebook, which works with LyX but is an independent project. License details (MIT) can be found in the file COPYING. Copyright (c) 2012 Allen Barker ========================================================================= This script runs the Lyx Notebook program. It mainly checks to make sure that there is no other active Lyx Notebook process running, and if not then it launches an instance of the main `ControllerOfLyxAndInterpreters` class. """ import os import sys import time from .config_file_processing import config_dict from .controller_of_lyx_and_interpreters import ControllerOfLyxAndInterpreters from . import gui lyx_user_directory = config_dict["lyx_user_directory"] lockfile_path = os.path.abspath(os.path.expanduser( os.path.join(lyx_user_directory, "lyxNotebook.lockfile"))) def main(): """ Make sure this script is not already running in an existing process. This method uses a lock file containing the PID, and was modified from code at http://shoaibmir.wordpress.com/2009/12/14/pid-lock-file-in-python/ """ # First check if a lock file already exists. if os.path.exists(lockfile_path): # If the lockfile is already there then check the PID number in the lock file. pidfile = open(lockfile_path, "r") pidfile.seek(0) old_PID = pidfile.readline() # Check if the PID from the lock file matches the current process PID. if os.path.exists(os.path.join("/proc", old_PID)): msg = ("You already have an instance of LyX Notebook running." "\nIt is running as process {}. Exiting.".format(old_PID)) print(msg) gui.text_warning_popup(msg) time.sleep(4) # For when a new terminal opened, so message can be read. sys.exit(1) else: # Lock file exists but the program is not running... remove it. os.remove(lockfile_path) # Put the current PID in the lock file. pidfile = open(lockfile_path, "w") pidfile.write(str(os.getpid())) pidfile.close() # # Start the main controller class. # print("\n===================================================\n") print("Starting the LyX Notebook program...") print("Version from source directory:\n ", config_dict["lyx_notebook_source_dir"]) controller = ControllerOfLyxAndInterpreters("lyxNotebookClient") controller.server_notify_loop()

f743bcd58d973e63c4a15c53633ff87895a7e899

py

Python

conans/client/uploader.py

TyRoXx/conan

644516b5126f78f46275a9f6a01148183c9d149f

conans/client/uploader.py

TyRoXx/conan

644516b5126f78f46275a9f6a01148183c9d149f

conans/client/uploader.py

TyRoXx/conan

644516b5126f78f46275a9f6a01148183c9d149f

import os from conans.errors import ConanException, NotFoundException from conans.model.ref import PackageReference class ConanUploader(object): def __init__(self, paths, user_io, remote_manager, remote): self._paths = paths self._user_io = user_io self._remote_manager = remote_manager self._remote = remote def upload_conan(self, conan_ref, force=False, all_packages=False): """Uploads the conans identified by conan_ref""" export_path = self._paths.export(conan_ref) if os.path.exists(export_path): if not force: self._check_package_date(conan_ref) self._user_io.out.info("Uploading %s" % str(conan_ref)) self._remote_manager.upload_conan(conan_ref, self._remote) if all_packages: for index, package_id in enumerate(self._paths.conan_packages(conan_ref)): total = len(self._paths.conan_packages(conan_ref)) self.upload_package(PackageReference(conan_ref, package_id), index + 1, total) else: self._user_io.out.error("There is no local conanfile exported as %s" % str(conan_ref)) def upload_package(self, package_ref, index=1, total=1): """Uploads the package identified by package_id""" msg = ("Uploading package %d/%d: %s" % (index, total, str(package_ref.package_id))) self._user_io.out.info(msg) self._remote_manager.upload_package(package_ref, self._remote) def _check_package_date(self, conan_ref): try: remote_conan_digest = self._remote_manager.get_conan_digest(conan_ref, self._remote) except NotFoundException: return # First upload local_digest = self._paths.load_digest(conan_ref) if remote_conan_digest.time > local_digest.time: raise ConanException("Remote conans is newer than local conans: " "\n Remote date: %s\n Local date: %s" % (remote_conan_digest.time, local_digest.time))

f743dd1533365cffd345d7d20e4b9a39695c05d4

py

Python

ogr2osm/__init__.py

roelderickx/ogr2pbf

7ac99488d8daa9452e2a41e40bf2554dc720166d

ogr2osm/__init__.py

roelderickx/ogr2pbf

7ac99488d8daa9452e2a41e40bf2554dc720166d

ogr2osm/__init__.py

roelderickx/ogr2pbf

7ac99488d8daa9452e2a41e40bf2554dc720166d

# -*- coding: utf-8 -*- ''' Copyright (c) 2012-2021 Roel Derickx, Paul Norman <penorman@mac.com>, Sebastiaan Couwenberg <sebastic@xs4all.nl>, The University of Vermont <andrew.guertin@uvm.edu>, github contributors Released under the MIT license, as given in the file LICENSE, which must accompany any distribution of this code. ''' from .translation_base_class import TranslationBase from .datawriter_base_class import DataWriterBase from .osm_datawriter import OsmDataWriter from .pbf_datawriter import PbfDataWriter from .ogr_datasource import OgrDatasource from .osm_data import OsmData

f743f48c490c683fd697c5d1f8f67b90aef3bce7

py

Python

knx/text/postagger/default_tagger.py

gofortargets/CNN_brandsafety

77c9048a7aca9458879585925e98220435c052e9

2017-07-27T03:50:37.000Z

2017-09-28T06:42:52.000Z

knx/text/postagger/default_tagger.py

gofortargets/CNN_brandsafety

77c9048a7aca9458879585925e98220435c052e9

knx/text/postagger/default_tagger.py

gofortargets/CNN_brandsafety

77c9048a7aca9458879585925e98220435c052e9

import logging LOGGER = logging.getLogger(__name__) try: # from .import stanford_tagger as postagger # LOGGER.debug('Use stanford_tagger') from . import perceptron_tagger as postagger LOGGER.debug('Use perceptron_tagger') except: from . import nltk_tagger as postagger LOGGER.debug('Use nltk_tagger') def tag(text): """Returns the POS tags of the text, using the default POS tagger (currently PerceptronTagger) Parameters ---------- text : str or iterable This is the text to be processed. If it's a str, it will be sentence tokenized and word tokenized using nltk If it's an iterable, it will be assumed to be a list of tokens Returns ------- tags : list List of (word, pos) tuples """ return postagger.tag(text) if __name__ == '__main__': import time start_time = time.time() print tag('The horse raced past the barn fell.') print 'Done tagging in %.3fs' % (time.time() - start_time) start_time = time.time() print tag(['The', 'horse', 'raced', 'past', 'the', 'barn', 'fell', '.']) print 'Done tagging (tokenized) in %.3fs' % (time.time() - start_time) while True: sentence = raw_input('Enter a sentence: ') start_time = time.time() print tag(sentence) print 'Done in %.3fs' % (time.time() - start_time)

f743fd4aab41716900ee63a6f68f8af1b6a32303

py

Python

hooks/obsolete_messages.py

mondeja/pre-commit-po-hooks

6c96941357699b283c46528d34821631e1aff324

hooks/obsolete_messages.py

mondeja/pre-commit-po-hooks

6c96941357699b283c46528d34821631e1aff324

2021-08-25T04:56:36.000Z

2022-02-25T16:47:39.000Z

hooks/obsolete_messages.py

mondeja/pre-commit-po-hooks

6c96941357699b283c46528d34821631e1aff324

"""Checks for obsolete messages in PO files. Returns an error code if a PO file has an obsolete message. """ import argparse import sys def check_obsolete_messages(filenames, quiet=False): """Warns about all obsolete messages found in a set of PO files. Parameters ---------- filenames : list Set of file names to check. quiet : bool, optional Enabled, don't print output to stderr when an obsolete message is found. Returns ------- int: 0 if no obsolete messages found, 1 otherwise. """ exitcode = 0 for filename in filenames: with open(filename) as f: content_lines = f.readlines() _inside_obsolete_message = False for i, line in enumerate(content_lines): if not _inside_obsolete_message and line.startswith("#~ "): _inside_obsolete_message = True exitcode = 1 if not quiet: sys.stderr.write(f"Found obsolete message at {filename}:{i + 1}\n") elif _inside_obsolete_message and not line.startswith("#~ "): _inside_obsolete_message = False return exitcode def main(): parser = argparse.ArgumentParser() parser.add_argument( "filenames", nargs="*", help="Filenames to check for obsolete messages" ) parser.add_argument("-q", "--quiet", action="store_true", help="Supress output") args = parser.parse_args() return check_obsolete_messages(args.filenames, quiet=args.quiet) if __name__ == "__main__": exit(main())

f743fe0f5d383fefb27261a22b64df7f8debdb2b

py

Python

migrations/versions/0122_add_service_letter_contact.py

cds-snc/notifier-api

90b385ec49efbaee7e607516fc7d9f08991af813

2019-11-28T16:58:41.000Z

2022-01-28T21:11:16.000Z

migrations/versions/0122_add_service_letter_contact.py

cds-snc/notification-api

b1c1064f291eb860b494c3fa65ac256ad70bf47c

2019-07-08T12:57:24.000Z

2022-03-08T18:53:40.000Z

migrations/versions/0122_add_service_letter_contact.py

cds-snc/notifier-api

90b385ec49efbaee7e607516fc7d9f08991af813

2020-01-24T19:56:43.000Z

2022-01-27T21:36:53.000Z

""" Revision ID: 0122_add_service_letter_contact Revises: 0121_nullable_logos Create Date: 2017-09-21 12:16:02.975120 """ import sqlalchemy as sa from alembic import op from sqlalchemy.dialects import postgresql revision = "0122_add_service_letter_contact" down_revision = "0121_nullable_logos" def upgrade(): op.create_table( "service_letter_contacts", sa.Column("id", postgresql.UUID(as_uuid=True), nullable=False), sa.Column("service_id", postgresql.UUID(as_uuid=True), nullable=False), sa.Column("contact_block", sa.Text(), nullable=False), sa.Column("is_default", sa.Boolean(), nullable=False), sa.Column("created_at", sa.DateTime(), nullable=False), sa.Column("updated_at", sa.DateTime(), nullable=True), sa.ForeignKeyConstraint( ["service_id"], ["services.id"], ), sa.PrimaryKeyConstraint("id"), ) op.create_index( op.f("ix_service_letter_contact_service_id"), "service_letter_contacts", ["service_id"], unique=False, ) def downgrade(): op.drop_index( op.f("ix_service_letter_contact_service_id"), table_name="service_letter_contacts", ) op.drop_table("service_letter_contacts")

f744154f010a7e14fc8b2467e849f89c2f8b44a6

py

Python

scons/templates/buster_py2_options.py

markendr/esys-escript.github.io

0023eab09cd71f830ab098cb3a468e6139191e8d

scons/templates/buster_py2_options.py

markendr/esys-escript.github.io

0023eab09cd71f830ab098cb3a468e6139191e8d

scons/templates/buster_py2_options.py

markendr/esys-escript.github.io

0023eab09cd71f830ab098cb3a468e6139191e8d

############################################################################## # # Copyright (c) 2003-2020 by The University of Queensland # http://www.uq.edu.au # # Primary Business: Queensland, Australia # Licensed under the Apache License, version 2.0 # http://www.apache.org/licenses/LICENSE-2.0 # # Development until 2012 by Earth Systems Science Computational Center (ESSCC) # Development 2012-2013 by School of Earth Sciences # Development from 2014 by Centre for Geoscience Computing (GeoComp) # Development from 2019 by School of Earth and Environmental Sciences # ############################################################################## # This is a template configuration file for escript on Debian/GNU Linux. # Refer to README_FIRST for usage instructions. escript_opts_version = 203 #cxx_extra = '-Wno-literal-suffix' openmp = True #mpi = 'OPENMPI' import os d_mpi_path = '/usr/include/openmpi' mpi_prefix = os.path.split(os.path.realpath(d_mpi_path))[0] mpi_libs = ['mpi_cxx', 'mpi'] netcdf = 4 umfpack = True umfpack_prefix = ['/usr/include/suitesparse', '/usr/lib'] umfpack_libs = ['umfpack', 'blas', 'amd'] lapack_prefix = ['/usr/include/atlas', '/usr/lib/atlas-base'] #silo = True silo_libs = ['siloh5', 'hdf5_openmpi'] dudley_assemble_flags = '-funroll-loops' pythoncmd="/usr/bin/python2" pythonlibname = 'python2.7' pythonlibpath = '/usr/lib/x86_64-linux-gnu/' pythonincpath = '/usr/include/python2.7' import subprocess import os p = subprocess.Popen(["ld","--verbose"], stdout=subprocess.PIPE) out,err = p.communicate() spath = [x[13:-3] for x in out.split() if 'SEARCH_DIR' in x] p2name = '' p3name = '' for name in spath: try: l=os.listdir(name) p2res=[x for x in l if x.startswith('libboost_python2') and x.endswith('.so')] p3res=[x for x in l if x.startswith('libboost_python3') and x.endswith('.so')] if len(p2name)==0 and len(p2res)>0: p2name=p2res[-1] if len(p3name)==0 and len(p3res)>0: p3name=p3res[-1] except OSError: pass # boost-python library/libraries to link against boost_libs = [p2name[3:-3]] # this can be used by options files importing us boost_py2_libs = [p2name[3:-3]] boost_py3_libs = [p3name[3:-3]] from site_init import getdebbuildflags # Now we add the debian build flags debstuff = getdebbuildflags() if len(debstuff) > 0: print("Building with the following additional flags from debian: "+str(debstuff)) for i in debstuff: k=i[0] v=i[1] try: exec(k+"+=' "+v+"'") except NameError: exec(k+"='"+v+"'") mathjax_path='/usr/share/javascript/mathjax/MathJax.js'

f7441e5310ab0a958ac934c6fcc8198fb0c61d64

py

Python

battleforcastile/utils/display_power.py

battleforcastile/battleforcastile

65223fcb56ecc550f1a7c7b70beadff22c866d85

battleforcastile/utils/display_power.py

battleforcastile/battleforcastile

65223fcb56ecc550f1a7c7b70beadff22c866d85

2021-08-21T10:16:03.000Z

2021-08-21T10:16:03.000Z

battleforcastile/utils/display_power.py

battleforcastile/battleforcastile

65223fcb56ecc550f1a7c7b70beadff22c866d85

def display_power(power: dict) -> str: name = power['name'] invocation_unit = power['invocation']['card_name'] invocation_instances = power['invocation']['num_instances'] cost = power['cost'] return f'{name} (Invocation: {invocation_instances} {invocation_unit}) - Cost: {cost}'

f74441db2773a5a826056f981dd9aed9b7cc6d50

py

Python

openrl/algorithms/imitation/imitation_learning.py

natetsang/open-rl

426723d0d6759672ce77e02afeb55cbeb68fcfb0

2021-09-10T18:52:35.000Z

2022-01-03T19:48:06.000Z

openrl/algorithms/imitation/imitation_learning.py

natetsang/open-rl

426723d0d6759672ce77e02afeb55cbeb68fcfb0

2021-12-28T17:42:23.000Z

2021-12-28T17:42:23.000Z

openrl/algorithms/imitation/imitation_learning.py

natetsang/open-rl

426723d0d6759672ce77e02afeb55cbeb68fcfb0

import gym import time import pickle import argparse import numpy as np import tensorflow as tf from typing import Callable, Union, Tuple, List from models.models import actor_fc_discrete_network, actor_critic_fc_discrete_network from algorithms.imitation.utils import plot_training_results from util.replay_buffer import ReplayBuffer # Set up GAMMA = 0.99 LEARNING_RATE = 0.0001 class ImitationAgent: def __init__(self, environment: gym.Env, model_fn: Callable[..., tf.keras.Model], optimizer: tf.keras.optimizers, run_dagger: bool, expert_policy, expert_data_path, replay_buffer: ReplayBuffer, model_kwargs: dict = None, train_kwargs: dict = None, save_dir: str = None) -> None: # Env vars self.env = environment self.state_dims = model_kwargs.get('state_dims') self.num_actions = model_kwargs.get('num_actions') num_hidden_layers = model_kwargs.get("num_hidden_layers") hidden_size = model_kwargs.get("hidden_size") # Algorithm self.run_dagger = run_dagger # Expert self.expert_policy = expert_policy self.expert_data = ImitationAgent.load_expert_data(expert_data_path) # Actor model self.model = model_fn(state_dims=self.state_dims, num_actions=self.num_actions, num_hidden_layers=num_hidden_layers, hidden_size=hidden_size) self.optimizer = optimizer self.loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False) # Discrete action space only # Replay buffer self.replay_buffer = replay_buffer # Training vars self.cur_episode = 0 self.total_steps = 0 self.max_ep_len = train_kwargs.get("max_ep_len") self.batch_size = train_kwargs.get("batch_size") # Batch size of data collection from buffer self.train_batch_size = train_kwargs.get('train_batch_size') # Batch size for training models self.eval_batch_size = train_kwargs.get('eval_batch_size') # Batch size for eval self.num_agent_train_steps_per_iter = train_kwargs.get('num_agent_train_steps_per_iter') # Grad updates per run # Save directories self.save_dir = save_dir def save_models(self) -> None: self.model.save(self.save_dir) def load_models(self) -> tf.keras.Model: self.model = tf.keras.models.load_model(self.save_dir) return self.model @staticmethod def load_expert_data(path): with open(path, 'rb') as f: expert_data = pickle.load(f) return expert_data def sample_random_trajectory(self) -> Tuple[List[Tuple], Union[int, float]]: """ Sample 1 trajectory. :param max_path_length: the maximum number of steps to take in the trajectory :param random: whether or not to sample actions randomly or using MPC :return: """ state = tf.expand_dims(tf.convert_to_tensor(self.env.reset()), 0) num_steps = 0 total_rewards = 0 transitions = [] # transition tuples (s,a,r,s',d) while True: num_steps += 1 action_prob = self.model(state) action = np.random.choice(self.num_actions, p=np.squeeze(action_prob)) next_state, reward, done, _ = self.env.step(action) next_state = tf.reshape(next_state, [1, self.state_dims]) total_rewards += reward if done or num_steps > self.max_ep_len: transitions.append((state, action, reward, next_state, 1)) break transitions.append((state, action, reward, next_state, 0)) state = next_state return transitions, total_rewards def sample_n_trajectories(self) -> Tuple[List, List, int]: """ Sample `self.batch_size` trajectories. Each trajectory should be no longer than `max_path_length` steps/transitions. Note that transitions are different than trajectories! A transition is a tuple (s,a,r,s',d) and a trajectory is made up of 1 to `max_path_length` transitions. :param batch_size: The number of transitions to sample. :param max_path_length: The maximum steps/transitions per trajectory :param random: Boolean to indicate whether or not to sample actions randomly or via MPC :return: """ num_steps_this_batch = 0 trajectory_rewards = [] transitions = [] while num_steps_this_batch < self.batch_size: traj, rews = self.sample_random_trajectory() num_steps_this_batch += len(traj) trajectory_rewards.append(rews) # Note that we're extending, not appending, because we don't care about trajectories, we care about # the transitions. If we appended, it would be ([[(tran 1), (tran 2)], ..., [(tran n), (tran n+1)]], # where each sublist is a trajectory. But by extending, it's instead ([(tran 1), ..., (tran n)] transitions.extend(traj) return transitions, trajectory_rewards, num_steps_this_batch def relabel_actions_with_expert(self, transitions: List[Tuple]) -> List[Tuple]: """ Given a batch of transition tuples, query the Expert Policy and update the action based on the Expert. This is the key difference between vanilla behavioral cloning and DAgger. This step is equivalent to asking a human expert to label our dataset with actions the correct actions. """ updated_transitions = [] for transition in transitions: state, action, reward, next_state, done = transition action_prob, _ = self.expert_policy(state) expert_action = np.argmax(np.squeeze(action_prob)) updated_transitions.append((state, expert_action, reward, next_state, done)) return updated_transitions def train_episode(self) -> List: # Step 1: Sample trajectories if self.cur_episode == 0: # Load expert_data transitions = self.expert_data else: # Or sample trajectories using current policy transitions, _, _ = self.sample_n_trajectories() # Step 2: For DAgger only, ask expert policy to label data with actions if self.run_dagger and self.cur_episode > 0: transitions = self.relabel_actions_with_expert(transitions) # Step 3: Store the sampled transitions in the replay buffer self.replay_buffer.store_transitions_batch(transitions) # Step 4: Train model! losses = [] for train_step in range(self.num_agent_train_steps_per_iter): # Sample a random batch of data from the replay buffer states, actions, _, _, _ = self.replay_buffer.sample(batch_size=self.train_batch_size) with tf.GradientTape() as tape: action_prob = self.model(states) loss = self.loss_fn(actions, action_prob) grads = tape.gradient(loss, self.model.trainable_variables) self.optimizer.apply_gradients(zip(grads, self.model.trainable_variables)) losses.append(loss) self.cur_episode += 1 return losses def run_agent(self, render=False) -> Tuple[float, int]: total_reward, total_steps = 0, 0 state = self.env.reset() done = False while not done: if render: self.env.render() # Select action action_prob = self.model(tf.expand_dims(state, axis=0)) action = np.argmax(np.squeeze(action_prob)) # Interact with environment state, reward, done, _ = self.env.step(action) # Bookkeeping total_reward += reward total_steps += 1 return total_reward, total_steps def main() -> None: # Check input params if args.run_dagger: assert args.epochs > 1, "DAgger needs more than 1 iteration of training, where each iter" \ "we query the expert and train" else: assert args.epochs == 1, "Vanilla behavior cloning collects expert data only once and does traditional" \ "supervised learning on that dataset." # Create environment env = gym.make(args.env) # Set seeds if args.seed: np.random.seed(args.seed) tf.random.set_seed(args.seed) env.seed(args.seed) # Create helper vars for model creation _state_dims = len(env.observation_space.high) _action_dims = 1 _num_actions = env.action_space.n # Create Replay Buffer buffer = ReplayBuffer(state_dims=_state_dims, action_dims=_action_dims) # Instantiate optimizer opt = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE) # Instantiate expert policy from file # TODO >> I think it's a bit cleaner to load the entire model instead of just the weights # but I'm getting a TF error that I think was fixed in a later version. I should probably # try updating the version and seeing if it fixes itself. expert = actor_critic_fc_discrete_network(state_dims=_state_dims, num_actions=_num_actions, num_hidden_layers=2, hidden_size=128) expert.load_weights(args.expert_policy_file) # Create agent agent = ImitationAgent(environment=env, model_fn=actor_fc_discrete_network, optimizer=opt, replay_buffer=buffer, run_dagger=args.run_dagger, expert_policy=expert, expert_data_path=args.expert_data, model_kwargs=dict(state_dims=_state_dims, num_actions=_num_actions, num_hidden_layers=2, hidden_size=256), train_kwargs=dict(max_ep_len=args.max_ep_len, batch_size=args.batch_size, train_batch_size=args.train_batch_size, eval_batch_size=args.eval_batch_size, num_agent_train_steps_per_iter=args.num_agent_train_steps_per_iter) ) # Run training ep_mean_rewards_history, ep_max_rewards_history, ep_min_rewards_history = [], [], [] ep_mean_loss_history, ep_max_loss_history, ep_min_loss_history = [], [], [] ep_steps_history = [] ep_wallclock_history = [] start = time.time() for e in range(args.epochs): # Run one episode ep_loss = agent.train_episode() ep_rew, ep_steps = agent.run_agent() # Prepare for logging mean_ep_rew, max_ep_rew, min_ep_rew, std_ep_rew = np.mean(ep_rew), np.max(ep_rew), np.min(ep_rew), np.std(ep_rew) mean_ep_loss, max_ep_loss, min_ep_loss = np.mean(ep_loss), np.max(ep_loss), np.min(ep_loss) ep_wallclock_history.append(time.time() - start) ep_mean_rewards_history.append(mean_ep_rew) ep_max_rewards_history.append(max_ep_rew) ep_min_rewards_history.append(min_ep_rew) ep_mean_loss_history.append(mean_ep_loss) ep_max_loss_history.append(max_ep_loss) ep_min_loss_history.append(min_ep_loss) ep_steps_history.append(ep_steps) template = "EPISODE {} | mean ep reward: {:.2f} - max ep reward: {:.2f}" \ " - min ep reward: {:.2f} - std ep reward: {:.2f} - mean ep loss {:.2f}" print(template.format(e, mean_ep_rew, max_ep_rew, min_ep_rew, std_ep_rew, mean_ep_loss)) # Now that we've completed training, let's plot the results print(f"Training time elapsed (sec): {round(time.time() - start, 2)}") # Let's evaluate the performance of the trained agent print("Beginning evaluation of trained agent!") eval_rew = [] for i in range(50): ep_rew, ep_steps = agent.run_agent() eval_rew.append(ep_rew) print(f"Evaluation rewards: mean - {np.mean(eval_rew)} | min - {np.min(eval_rew)} | max - {np.max(eval_rew)}") # Plot summary of results plot_training_results(mean_rewards_history=ep_mean_rewards_history, max_rew_history=ep_max_rewards_history, min_rew_history=ep_min_rewards_history, mean_loss_history=ep_mean_loss_history, max_loss_history=ep_max_loss_history, min_loss_history=ep_min_loss_history, steps_history=ep_steps_history, wallclock_history=ep_wallclock_history, save_dir="./results.png") if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument("--seed", type=int, default=1) parser.add_argument("--env", type=str, default="CartPole-v0") parser.add_argument('--expert_policy_file', type=str, default='./checkpoints/expert_model_weights') parser.add_argument('--expert_data', type=str, default='expert_data.pkl') # parser.add_argument("--run_dagger", action="store_false") parser.add_argument("--run_dagger", type=bool, default=False) parser.add_argument("--epochs", type=int, default=1) parser.add_argument('--max_ep_len', type=int, default=100) # max trajectory length parser.add_argument('--num_agent_train_steps_per_iter', type=int, default=20) # number of grad updates per iter parser.add_argument('--batch_size', type=int, default=1000) # num steps/transitions to sample for itr 1+ parser.add_argument('--train_batch_size', type=int, default=512) # training batch size per model parser.add_argument('--eval_batch_size', type=int, default=400) # steps collected per eval iteration args = parser.parse_args() main()

f74451751805bace06484342526dd58e1fdcc09d

py

Python

train.py

BXuan694/SOLO-pytorch

aef0ac47ce6989f6633fe4f71070bd6944c39abb

2022-03-19T12:58:58.000Z

2022-03-19T15:01:02.000Z

train.py

BXuan694/SOLO-pytorch

aef0ac47ce6989f6633fe4f71070bd6944c39abb

2022-03-19T15:06:25.000Z

2022-03-23T01:48:58.000Z

train.py

BXuan694/SOLO-pytorch

aef0ac47ce6989f6633fe4f71070bd6944c39abb

from data.config import cfg, process_funcs_dict from data.coco import CocoDataset from data.loader import build_dataloader #from modules.solov1 import SOLOV1 as solo # from modules.solov2 import SOLOV2 as solo from modules.solov1d import SOLOV1 as solo import time import torch import numpy as np # 梯度均衡 def clip_grads(params_): params_ = list(filter(lambda p: p.requires_grad and p.grad is not None, params_)) if len(params_) > 0: return torch.nn.utils.clip_grad.clip_grad_norm_(params_, max_norm=35, norm_type=2) # 设置新学习率 def set_lr(optimizer_, newLr_): for paramGroup_ in optimizer_.param_groups: paramGroup_['lr'] = newLr_ # 设置requires_grad为False def gradinator(x_): x_.requires_grad = False return x_ # 设置pipline def build_process_pipeline(pipelineConfgs_): assert isinstance(pipelineConfgs_, list) process_pipelines = [] for pConfig_ in pipelineConfgs_: assert isinstance(pConfig_, dict) and 'type' in pConfig_ args = pConfig_.copy() obj_type = args.pop('type') if isinstance(obj_type, str): process_pipelines.append(process_funcs_dict[obj_type](**args)) return process_pipelines # 计算warmup学习率 def get_warmup_lr(curIter_, totalIters_, baseLr_, warmupRatio_, warmUpOption='linear'): if warmUpOption == 'constant': warmupLr = baseLr_ * warmupRatio_ elif warmUpOption == 'linear': k = (1 - curIter_ / totalIters_) * (1 - warmupRatio_) warmupLr = baseLr_ * (1 - k) elif warmUpOption == 'exp': k = warmupRatio_**(1 - curIter_ / totalIters_) warmupLr = baseLr_ * k return warmupLr def train(globalStartEpoch, totalEpoches): # train process pipelines func trainTransformsPiplines = build_process_pipeline(cfg.train_pipeline) print(trainTransformsPiplines) # build datashet casiadata = CocoDataset(ann_file=cfg.dataset.train_info, pipeline = trainTransformsPiplines, img_prefix = cfg.dataset.trainimg_prefix, data_root=cfg.dataset.train_prefix) torchdataLoader = build_dataloader(casiadata, cfg.imgs_per_gpu, cfg.workers_per_gpu, num_gpus=cfg.num_gpus, shuffle=True) if cfg.resume_from is None: model = solo(cfg, pretrained=None, mode='train') print('cfg.resume_from is None') else: model = solo(cfg, pretrained=cfg.resume_from, mode='train') model = model.cuda() model = model.train() lrOri = cfg.optimizer['lr'] lrStages = cfg.lr_config["step"] lrList = np.full(totalEpoches, lrOri) for ii in range(len(lrStages)): lrList[lrStages[ii]:]*=0.1 print("starting epoch: ", globalStartEpoch) print("lr adapting stages: ", end=' ') for ii in range(len(lrStages)): print(cfg.lr_config["step"][ii], end=" ") print("\ntotal training epoches: ", totalEpoches) optimizer_config = cfg.optimizer optimizer = torch.optim.SGD(model.parameters(), lr=optimizer_config['lr'], momentum=optimizer_config['momentum'], weight_decay=optimizer_config['weight_decay']) batchSize = cfg.imgs_per_gpu * cfg.num_gpus epochSize = len(casiadata) // batchSize # nums of trained epoches, idx of epoch to start pastEpoches = globalStartEpoch # nums of trained iters, idx of iter to start pastIters = (globalStartEpoch-1) * epochSize # nums of left epoches leftEpoches = totalEpoches - pastEpoches + 1 # nums of left iters leftIters = leftEpoches * epochSize print('##### begin train ######') currentIter = 0 for epoch in range(leftEpoches): currentEpoch = epoch + pastEpoches # 终止训练 if currentEpoch >= totalEpoches: print("Current epoch is larger than setting epoch nums, training stop.") return # 仅用于打印 loss_sum = 0.0 loss_ins = 0.0 loss_cate = 0.0 for j, data in enumerate(torchdataLoader): iterStartTime = time.time() if cfg.lr_config['warmup'] is not None and pastIters < cfg.lr_config['warmup_iters']: cur_lr = get_warmup_lr(pastIters, cfg.lr_config['warmup_iters'], optimizer_config['lr'], cfg.lr_config['warmup_ratio'], cfg.lr_config['warmup']) else: cur_lr = lrList[currentEpoch] set_lr(optimizer, cur_lr) imgs = gradinator(data['img'].data[0].cuda()) img_meta = data['img_metas'].data[0] #图片的一些原始信息 gt_bboxes = [] for bbox in data['gt_bboxes'].data[0]: bbox = gradinator(bbox.cuda()) gt_bboxes.append(bbox) gt_masks = data['gt_masks'].data[0] #cpu numpy data gt_labels = [] for label in data['gt_labels'].data[0]: label = gradinator(label.cuda()) gt_labels.append(label) loss = model.forward(img=imgs, img_meta=img_meta, gt_bboxes=gt_bboxes, gt_labels=gt_labels, gt_masks=gt_masks) losses = loss['loss_ins'] + loss['loss_cate'] loss_sum += losses.cpu().item() loss_ins += loss['loss_ins'].cpu().item() loss_cate += loss['loss_cate'].cpu().item() optimizer.zero_grad() losses.backward() if torch.isfinite(losses).item(): grad_norm = clip_grads(model.parameters()) #梯度平衡 optimizer.step() else: NotImplementedError("loss type error!can't backward!") leftIters -= 1 pastIters += 1 currentIter += 1 showIters = 10 if j%int(showIters) == 0 and j != 0: iterLastTime = time.time() - iterStartTime left_seconds = iterLastTime * leftIters left_minutes = left_seconds / 60.0 left_hours = left_minutes / 60.0 left_days = left_hours // 24 left_hours = left_hours % 24 out_srt = 'epoch:['+str(currentEpoch)+']/['+str(totalEpoches)+'],' # end of epoch of idx currentEpoch out_srt = out_srt + '['+str(j)+']/'+str(epochSize)+'], left_time: ' + str(left_days)+'days '+format(left_hours,'.2f')+'hours,' print(out_srt, "loss:", format(loss_sum/showIters,'.4f'), 'loss_ins:', format(loss_ins/showIters,'.4f'), "loss_cate:", format(loss_cate/showIters,'.4f'), "lr:", format(cur_lr,'.8f')) loss_sum = 0.0 loss_ins = 0.0 loss_cate = 0.0 leftEpoches -= 1 save_name = "./weights/solo1/" + cfg.name + "_epoch_" + str(currentEpoch) + ".pth" model.save_weights(save_name) if __name__ == '__main__': train(globalStartEpoch=cfg.epoch_iters_start, totalEpoches=cfg.total_epoch) #设置本次训练的起始epoch

f7446ab7e38ca354c89e6ca03d9847a06491b576

py

Python

chainer/links/cnet/link_cnet_linear.py

asrlabncku/RAP

11fab37c8d98257ec0aed1b306aa9709a3a51328

chainer/links/cnet/link_cnet_linear.py

asrlabncku/RAP

11fab37c8d98257ec0aed1b306aa9709a3a51328

chainer/links/cnet/link_cnet_linear.py

asrlabncku/RAP

11fab37c8d98257ec0aed1b306aa9709a3a51328

from __future__ import absolute_import import numpy from chainer import link from chainer.functions.cnet import function_cnet_linear import math from chainer import initializers from chainer import cuda class CnetLinear(link.Link): """Binary Linear layer (a.k.a. binary fully-connected layer). This is a link that wraps the :func:`~chainer.functions.linear` function, and holds a weight matrix ``W`` and optionally a bias vector ``b`` as parameters. The weight matrix ``W`` is initialized with i.i.d. Gaussian samples, each of which has zero mean and deviation :math:`\\sqrt{1/\\text{in_size}}`. The bias vector ``b`` is of size ``out_size``. Each element is initialized with the ``bias`` value. If ``nobias`` argument is set to True, then this link does not hold a bias vector. Args: in_size (int): Dimension of input vectors. out_size (int): Dimension of output vectors. wscale (float): Scaling factor of the weight matrix. bias (float): Initial bias value. nobias (bool): If True, then this function does not use the bias. initialW (2-D array): Initial weight value. If ``None``, then this function uses to initialize ``wscale``. initial_bias (1-D array): Initial bias value. If ``None``, then this function uses to initialize ``bias``. .. seealso:: :func:`~chainer.functions.linear` Attributes: W (~chainer.Variable): Weight parameter. b (~chainer.Variable): Bias parameter. """ def __init__(self, in_size, out_size, wscale=1, bias=0, nobias=False, initialW=None, initial_bias=None): super(CnetLinear, self).__init__() self.cname = "l_cnet_linear" # For backward compatibility self.initialW = initialW self.wscale = wscale self.out_size = out_size # For backward compatibility, the scale of weights is proportional to # the square root of wscale. self._W_initializer = initializers._get_initializer( initialW, math.sqrt(wscale)) if in_size is None: self.add_uninitialized_param('W') else: self._initialize_params(in_size) if nobias: self.b = None else: if initial_bias is None: initial_bias = bias bias_initializer = initializers._get_initializer(initial_bias) self.add_param('b', out_size, initializer=bias_initializer) def _initialize_params(self, in_size): self.add_param('W', (self.out_size, in_size), initializer=self._W_initializer) def __call__(self, x): """Applies the linear layer. Args: x (~chainer.Variable): Batch of input vectors. Returns: ~chainer.Variable: Output of the linear layer. """ if self.has_uninitialized_params: with cuda.get_device(self._device_id): self._initialize_params(x.size // len(x.data)) return function_cnet_linear.cnet_linear(x, self.W, self.b)

f744817e85fdb412c5892b7d65c53e54ebb20095

py

Python

django-edx-courseware/urls.py

mjrulesamrat/django-edx-courseware

ec47a67e94b71ff95bb009fa95c47c76c21553da

django-edx-courseware/urls.py

mjrulesamrat/django-edx-courseware

ec47a67e94b71ff95bb009fa95c47c76c21553da

django-edx-courseware/urls.py

mjrulesamrat/django-edx-courseware

ec47a67e94b71ff95bb009fa95c47c76c21553da

__author__ = 'Jay Modi' from django.conf import settings from django.conf.urls import patterns, include, url from .views import course_data urlpatterns = [ url( r'^courses-data/{}$'.format( settings.COURSE_ID_PATTERN, ), course_data, name='edx_course_progress', ), ]

f7448f164d943f9205f7ff40068c9d8aff1896f8

py

Python

apps/sushi/migrations/0023_sushicredentials_last_updated_by.py

remocrevo/celus

682b13168eb475d7f970502113e756e40a899877

apps/sushi/migrations/0023_sushicredentials_last_updated_by.py

remocrevo/celus

682b13168eb475d7f970502113e756e40a899877

apps/sushi/migrations/0023_sushicredentials_last_updated_by.py

remocrevo/celus

682b13168eb475d7f970502113e756e40a899877

# Generated by Django 2.2.5 on 2019-10-21 07:13 from django.conf import settings from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ('sushi', '0022_sushi_credentials_locking'), ] operations = [ migrations.AddField( model_name='sushicredentials', name='last_updated_by', field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, to=settings.AUTH_USER_MODEL), ), ]

f74491c60ad7411487d7485ccbfd1015420a2fac

py

Python

the_millionaire/users/admin.py

mrsaemir/the_millionaire

3fe2c9c114b43648b1c2e039589733bbf778b7f6

the_millionaire/users/admin.py

mrsaemir/the_millionaire

3fe2c9c114b43648b1c2e039589733bbf778b7f6

the_millionaire/users/admin.py

mrsaemir/the_millionaire

3fe2c9c114b43648b1c2e039589733bbf778b7f6

from django.contrib import admin from django.contrib.auth import admin as auth_admin from django.contrib.auth import get_user_model from django.utils.translation import gettext_lazy as _ from the_millionaire.users.forms import UserChangeForm, UserCreationForm User = get_user_model() @admin.register(User) class UserAdmin(auth_admin.UserAdmin): form = UserChangeForm add_form = UserCreationForm fieldsets = ( (None, {"fields": ("username", "password")}), (_("Personal info"), {"fields": ("name", "email")}), ( _("Permissions"), { "fields": ( "is_active", "is_staff", "is_superuser", "groups", "user_permissions", ), }, ), (_("Important dates"), {"fields": ("last_login", "date_joined")}), ) list_display = ["username", "name", "is_superuser"] search_fields = ["name"]

f74493fb8ff35c1840480038021304caa1379835

py

Python

photons.py

mfkoerner/icarus

eb480596be127f760d10531d27569290df3e8ff9

2018-02-21T23:23:53.000Z

2019-05-22T11:05:03.000Z

photons.py

mfkoerner/icarus

eb480596be127f760d10531d27569290df3e8ff9

photons.py

mfkoerner/icarus

eb480596be127f760d10531d27569290df3e8ff9

######################################## # written for Python 3 # # by Doug Fabini (fabini@mrl.ucsb.edu) # ######################################## ''' This script requires the following files to be located in 'baseDir': - IBZKPT (to extract number of k points) POSSIBLY NO LONGER NEEDED - DOSCAR (to extract bandgap) - OUTCAR (to extract dielectric properties and energy resolution) Currently only handles an isotropic equivalent for the dielectric / absorption tensors. ''' # import packages, apply stylesheet import config import os from electrons import np, plt, getTotalDOS, bandgap # ****************** # # DATA I/O FUNCTIONS # # ****************** # def getNkPts(bd): ''' Parse OUTCAR for number of k-points ''' fname = os.path.join(bd, 'OUTCAR') # print(fname) #debug line with open(fname, 'r') as f: for line in f: if 'irreducible k-points' in line: # print(line) #debug line return int(line.split()[1]) break def getDielectric(bd, anisotropic=False): ''' Parse OUTCAR for dielectric properties, convert to appropriate form ''' fname = os.path.join(bd, 'OUTCAR') with open(fname, 'r') as f: raw = [] lnImag, lnReal = 0, 0 for i, line in enumerate(f): raw.append(line) if 'NEDOS' in line: #This an below find number points per section and start of lines for sections NEDOS = int(line.split()[5]) if 'IMAGINARY DIELECTRIC' in line and lnImag is 0: #Selecting the first set of Dielectric numbers from VASP lnImag = i if 'REAL DIELECTRIC' in line and lnReal is 0: lnReal = i EepsRe, EepsIm = [], [] for i in range(lnImag+3,lnImag+NEDOS+3): #All of the imaginary dielectric components (NEDOS components and start point of lnImag+3) if len(raw[i]) < 5: #Checking for early termination of DIELECTRIC DATA (printing to output) print('DIELECTRIC DATA TERMINATED AT ONLY {} POINTS'.format(i-lnImag-3)) break EepsIm.append([float(ri) for ri in raw[i].strip('\n').split()]) #Energy (frequency) then X,Y,Z,XY,YZ,ZX for imaginary component E = np.array(EepsIm)[:,0] #Energies pulled from first part of EepsIm for i in range(lnReal+3,lnReal+NEDOS+3): if len(raw[i]) < 5: # print('DIELECTRIC DATA TERMINATED AT ONLY {} POINTS'.format(i-lnReal-3)) break EepsRe.append([float(ri) for ri in raw[i].strip('\n').split()]) #Real part from above if anisotropic: epsIm = np.array([row[1:] for row in EepsIm]) epsRe = np.array([row[1:] for row in EepsRe]) else: epsIm = np.array([isotropic(row[1:]) for row in EepsIm]) #epsIm is the isotropic equivilent values for each energy epsRe = np.array([isotropic(row[1:]) for row in EepsRe]) #Real part for epsIm, this time is epsRe return E, epsRe + 1j*epsIm #Returns list of isotropic equivalent values def saveResults(bd, E, alpha, eps): ''' Store absorption coefficient and dielectric function ''' out = np.hstack((E, alpha, eps.real, eps.imag)) out = np.reshape(out, (-1, 4), order='F') np.savetxt(os.path.join(bd, 'optical.csv'), out, header='h*nu (eV), alpha_iso (cm^-1), Re[eps_iso] (eps_0), Im[eps_iso] (eps_0)') def getSolarSpectrum(): ''' Get direct+diffuse solar irradiance at global tilt, ASTM G173-03 ''' d = np.loadtxt('data/ASTMG173.dat') return d[:,0], d[:,2] # ****************** # # ANALYSIS FUNCTIONS # # ****************** # def nm2eV(lam): ''' Convert wavelength in nm to energy in eV ''' h = 4.136e-15 # Planck constant, eV / s c = 2.998e8 # speed of light, m / s return h*c/(lam*1e-9) def eV2nm(hnu): ''' Convert energy in eV to wavelength in nm ''' h = 4.136e-15 # Planck constant, eV / s c = 2.998e8 # speed of light, m / s return h*c/hnu*1e9 def isotropic(sixElements): ''' Returns an isotropic equivalent value for a symmetric 3x3 matrix ''' xx, yy, zz, xy, yz, zx = sixElements A = np.array([[xx, xy, zx], [xy, yy, yz], [zx, yz, zz]]) eigval, _ = np.linalg.eigh(A) return np.mean(eigval) def dielec2optical(hnu, eps): ''' Calculate complex refractive index and absorption coefficient from dielectric function ''' h = 4.136e-15 # Planck constant, eV / s c = 2.998e8 # speed of light, m / s N = np.sqrt(eps) alpha = 4*np.pi/(h*c)*hnu*N.imag/100 # divisor of 100 takes from m-1 to cm-1 return N, alpha def FOM(hnu, alpha, Eg): xx = np.linspace(100, eV2nm(Eg), int(1e4)) #proper range of light to think about (100 nm [13eV] to band gap wavelength) xSun, ySun = getSolarSpectrum() #xSun -> wavelength of sun, ySun -> intensity of sun yySun = np.interp(xx, xSun, ySun) #ySun calculated at the points for xx (so that we have the right resolution) yyMat = np.interp(xx, np.flipud(eV2nm(hnu[1:])), np.flipud(alpha[1:])) #absorption as a function of wavelength from scipy.integrate import cumtrapz #Trapezoidal numeric integration return xx, yySun, yyMat, cumtrapz(yySun*yyMat, xx) #FOM is the last value, which is integral of sum intensity time absorption along wavel # ****************** # # PLOTTING FUNCTIONS # # ****************** # def plotDielectric(ax, E, eps, N, El=(0, 10)): ''' Plot complex dielectric function and complex refractive index ''' ax.plot(E, eps.real, label='$\\epsilon_r\\prime$') ax.plot(E, eps.imag, label='$\\epsilon_r\\prime\\prime$') ax.plot(E, N.real, label='$n$') ax.plot(E, N.imag, label='$k$') ax.set_xlim(El) ax.set_xlabel('$h\\nu$ (eV)') ax.legend() def plotAbsorption(ax, hnu, alpha, xl=(0, 4), yl=(1e2, 1e7), rel2eg=None, lbl=None, wavelength=False): ''' Plot absorption coefficient ''' if wavelength: if rel2eg is not None: raise Exception('Relative to gap option not available when plotting by wavelength') lh, = ax.semilogy(eV2nm(hnu), alpha, '.-', label=lbl) ax.set_xlabel('$\\lambda$ (nm)') elif not wavelength and rel2eg is None: lh, = ax.semilogy(hnu, alpha, '.-', label=lbl) ax.set_xlabel('$h\\nu$ (eV)') else: lh, = ax.semilogy(hnu-rel2eg, alpha, '.-', label=lbl) ax.set_xlabel('$h\\nu-E_g$ (eV)') ax.set_xlim(xl) ax.set_ylim(yl) ax.set_ylabel('$\\alpha$ (cm$^{-1}$)') return lh # ********** # # HIGH LEVEL # # ********** # def optical(bd, save=False): ''' DESCRIPTION GOES HERE ''' Nk = getNkPts(bd) #Gets number of irreducible kpoints but never uses it :O E, eps = getDielectric(bd) #Gets lists of E and equivilent eigenvalues (real + i*imag) for dialectric function N, alpha = dielec2optical(E, eps) #N (dielectric constant) and alpha (absorption coefficient) from dielectric equivilent eigenvalues Edos, tdos = getTotalDOS(bd) #arrays of len NEDOS with energy and DOS at that energy Eg = bandgap(Edos, tdos) #Calculates bandgap from DOS data if save: saveResults(bd, E, alpha, eps) #Saves Energy, absorption, eigenvalue to basedir/optical.csv return E, alpha, eps, N, Eg #Returns Energy, absorption, eigenvalue, refractive index, bandgap

f7452da095e19f5494b730624c0e1cac04e623b7

py

Python

etl/jobs/transformation/patient_transformer_job.py

PDXFinder/pdcm-etl

3caf80938d9e80f1fc7bb0724cba6ae68a8d315e

2021-05-24T14:54:48.000Z

2021-05-24T14:54:48.000Z

etl/jobs/transformation/patient_transformer_job.py

PDCMFinder/pdcm-etl

df0006e4ad5ca2ddf9c1387e28a0b7fb24f195de

2022-02-09T18:19:13.000Z

2022-03-29T12:14:19.000Z

etl/jobs/transformation/patient_transformer_job.py

PDCMFinder/pdcm-etl

df0006e4ad5ca2ddf9c1387e28a0b7fb24f195de

import sys from pyspark.sql import DataFrame, SparkSession from etl.constants import Constants from etl.jobs.util.cleaner import init_cap_and_trim_all from etl.jobs.util.dataframe_functions import transform_to_fk from etl.jobs.util.id_assigner import add_id def main(argv): """ Creates a parquet file with patient data. :param list argv: the list elements should be: [1]: Parquet file path with raw model data [2]: Parquet file path with diagnosis data [3]: Parquet file path with ethnicity data [4]: Parquet file path with provider group data [5]: Output file """ raw_patient_parquet_path = argv[1] diagnosis_parquet_path = argv[2] ethnicity_parquet_path = argv[3] provider_group_parquet_path = argv[4] output_path = argv[5] spark = SparkSession.builder.getOrCreate() raw_patient_df = spark.read.parquet(raw_patient_parquet_path) diagnosis_df = spark.read.parquet(diagnosis_parquet_path) ethnicity_df = spark.read.parquet(ethnicity_parquet_path) provider_group_df = spark.read.parquet(provider_group_parquet_path) patient_df = transform_patient(raw_patient_df, diagnosis_df, ethnicity_df, provider_group_df) # Temporary fix to remove null rows patient_df = patient_df.where("external_patient_id is not null") patient_df.write.mode("overwrite").parquet(output_path) def transform_patient( raw_patient_df: DataFrame, diagnosis_df: DataFrame, ethnicity_df: DataFrame, provider_group_df: DataFrame) -> DataFrame: patient_df = clean_data_before_join(raw_patient_df) patient_df = set_fk_diagnosis(patient_df, diagnosis_df) patient_df = set_fk_ethnicity(patient_df, ethnicity_df) patient_df = set_fk_provider_group(patient_df, provider_group_df) patient_df = set_external_id(patient_df) patient_df = add_id(patient_df, "id") patient_df = get_columns_expected_order(patient_df) return patient_df def clean_data_before_join(patient_df: DataFrame) -> DataFrame: patient_df = patient_df.withColumn("ethnicity", init_cap_and_trim_all("ethnicity")) return patient_df.drop_duplicates() def set_fk_diagnosis(raw_patient_df: DataFrame, diagnosis_df: DataFrame) -> DataFrame: patient_df = transform_to_fk( raw_patient_df, diagnosis_df, "initial_diagnosis", "name", "id", "initial_diagnosis_id") return patient_df def set_fk_ethnicity(patient_df: DataFrame, ethnicity_df: DataFrame) -> DataFrame: patient_df = transform_to_fk(patient_df, ethnicity_df, "ethnicity", "name", "id", "ethnicity_id") return patient_df def set_fk_provider_group(patient_df: DataFrame, provider_group_df: DataFrame) -> DataFrame: provider_group_df = provider_group_df.withColumnRenamed("id", "provider_group_id") patient_df = patient_df.join(provider_group_df, on=[Constants.DATA_SOURCE_COLUMN], how='left') return patient_df def set_external_id(patient_df: DataFrame) -> DataFrame: return patient_df.withColumnRenamed("patient_id", "external_patient_id") def get_columns_expected_order(patient_df: DataFrame) -> DataFrame: return patient_df.select( "id", "external_patient_id", "sex", "history", "ethnicity_id", "ethnicity_assessment_method", "initial_diagnosis_id", "age_at_initial_diagnosis", "provider_group_id", Constants.DATA_SOURCE_COLUMN) if __name__ == "__main__": sys.exit(main(sys.argv))

f7454d807cf9346638540e5b9826adcab1db2bb3

py

Python

neo/io/brainwaredamio.py

deeptimittal12/python-neo

7409f47b5debd4d2a75bbf0e77ac10562446c97a

2020-06-08T14:00:03.000Z

2020-06-08T14:00:03.000Z

neo/io/brainwaredamio.py

deeptimittal12/python-neo

7409f47b5debd4d2a75bbf0e77ac10562446c97a

neo/io/brainwaredamio.py

deeptimittal12/python-neo

7409f47b5debd4d2a75bbf0e77ac10562446c97a

''' Class for reading from Brainware DAM files DAM files are binary files for holding raw data. They are broken up into sequence of Segments, each containing a single raw trace and parameters. The DAM file does NOT contain a sampling rate, nor can it be reliably calculated from any of the parameters. You can calculate it from the "sweep length" attribute if it is present, but it isn't always present. It is more reliable to get it from the corresponding SRC file or F32 file if you have one. The DAM file also does not divide up data into Blocks, so only a single Block is returned.. Brainware was developed by Dr. Jan Schnupp and is availabe from Tucker Davis Technologies, Inc. http://www.tdt.com/downloads.htm Neither Dr. Jan Schnupp nor Tucker Davis Technologies, Inc. had any part in the development of this code The code is implemented with the permission of Dr. Jan Schnupp Author: Todd Jennings ''' # import needed core python modules import os import os.path # numpy and quantities are already required by neo import numpy as np import quantities as pq # needed core neo modules from neo.core import (AnalogSignal, Block, ChannelIndex, Segment) # need to subclass BaseIO from neo.io.baseio import BaseIO class BrainwareDamIO(BaseIO): """ Class for reading Brainware raw data files with the extension '.dam'. The read_block method returns the first Block of the file. It will automatically close the file after reading. The read method is the same as read_block. Note: The file format does not contain a sampling rate. The sampling rate is set to 1 Hz, but this is arbitrary. If you have a corresponding .src or .f32 file, you can get the sampling rate from that. It may also be possible to infer it from the attributes, such as "sweep length", if present. Usage: >>> from neo.io.brainwaredamio import BrainwareDamIO >>> damfile = BrainwareDamIO(filename='multi_500ms_mulitrep_ch1.dam') >>> blk1 = damfile.read() >>> blk2 = damfile.read_block() >>> print blk1.segments >>> print blk1.segments[0].analogsignals >>> print blk1.units >>> print blk1.units[0].name >>> print blk2 >>> print blk2[0].segments """ is_readable = True # This class can only read data is_writable = False # write is not supported # This class is able to directly or indirectly handle the following objects # You can notice that this greatly simplifies the full Neo object hierarchy supported_objects = [Block, ChannelIndex, Segment, AnalogSignal] readable_objects = [Block] writeable_objects = [] has_header = False is_streameable = False # This is for GUI stuff: a definition for parameters when reading. # This dict should be keyed by object (`Block`). Each entry is a list # of tuple. The first entry in each tuple is the parameter name. The # second entry is a dict with keys 'value' (for default value), # and 'label' (for a descriptive name). # Note that if the highest-level object requires parameters, # common_io_test will be skipped. read_params = {Block: []} # do not support write so no GUI stuff write_params = None name = 'Brainware DAM File' extensions = ['dam'] mode = 'file' def __init__(self, filename=None): ''' Arguments: filename: the filename ''' BaseIO.__init__(self) self._path = filename self._filename = os.path.basename(filename) self._fsrc = None def read(self, lazy=False, **kargs): ''' Reads raw data file "fname" generated with BrainWare ''' assert not lazy, 'Do not support lazy' return self.read_block(lazy=lazy) def read_block(self, lazy=False, **kargs): ''' Reads a block from the raw data file "fname" generated with BrainWare ''' assert not lazy, 'Do not support lazy' # there are no keyargs implemented to so far. If someone tries to pass # them they are expecting them to do something or making a mistake, # neither of which should pass silently if kargs: raise NotImplementedError('This method does not have any ' 'arguments implemented yet') self._fsrc = None block = Block(file_origin=self._filename) # create the objects to store other objects chx = ChannelIndex(file_origin=self._filename, channel_ids=np.array([1]), index=np.array([0]), channel_names=np.array(['Chan1'], dtype='S')) # load objects into their containers block.channel_indexes.append(chx) # open the file with open(self._path, 'rb') as fobject: # while the file is not done keep reading segments while True: seg = self._read_segment(fobject) # if there are no more Segments, stop if not seg: break # store the segment and signals seg.analogsignals[0].channel_index = chx block.segments.append(seg) # remove the file object self._fsrc = None block.create_many_to_one_relationship() return block # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # IMPORTANT!!! # These are private methods implementing the internal reading mechanism. # Due to the way BrainWare DAM files are structured, they CANNOT be used # on their own. Calling these manually will almost certainly alter your # position in the file in an unrecoverable manner, whether they throw # an exception or not. # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- def _read_segment(self, fobject): ''' Read a single segment with a single analogsignal Returns the segment or None if there are no more segments ''' try: # float64 -- start time of the AnalogSignal t_start = np.fromfile(fobject, dtype=np.float64, count=1)[0] except IndexError: # if there are no more Segments, return return False # int16 -- index of the stimulus parameters seg_index = np.fromfile(fobject, dtype=np.int16, count=1)[0].tolist() # int16 -- number of stimulus parameters numelements = np.fromfile(fobject, dtype=np.int16, count=1)[0] # read the name strings for the stimulus parameters paramnames = [] for _ in range(numelements): # unit8 -- the number of characters in the string numchars = np.fromfile(fobject, dtype=np.uint8, count=1)[0] # char * numchars -- a single name string name = np.fromfile(fobject, dtype=np.uint8, count=numchars) # exclude invalid characters name = str(name[name >= 32].view('c').tostring()) # add the name to the list of names paramnames.append(name) # float32 * numelements -- the values for the stimulus parameters paramvalues = np.fromfile(fobject, dtype=np.float32, count=numelements) # combine parameter names and the parameters as a dict params = dict(zip(paramnames, paramvalues)) # int32 -- the number elements in the AnalogSignal numpts = np.fromfile(fobject, dtype=np.int32, count=1)[0] # int16 * numpts -- the AnalogSignal itself signal = np.fromfile(fobject, dtype=np.int16, count=numpts) sig = AnalogSignal(signal.astype(np.float) * pq.mV, t_start=t_start * pq.d, file_origin=self._filename, sampling_period=1. * pq.s, copy=False) # Note: setting the sampling_period to 1 s is arbitrary # load the AnalogSignal and parameters into a new Segment seg = Segment(file_origin=self._filename, index=seg_index, **params) seg.analogsignals = [sig] return seg

f7457bda10287c1c64239c9802aa4e6293ce12bf

py

Python

canalystii/device.py

projectgus/python-canalystii

7ef3a4a369a88976291ea91f93ef2b8c322855b9

2021-09-09T16:30:20.000Z

2022-03-11T10:29:19.000Z

canalystii/device.py

projectgus/python-canalystii

7ef3a4a369a88976291ea91f93ef2b8c322855b9

canalystii/device.py

projectgus/python-canalystii

7ef3a4a369a88976291ea91f93ef2b8c322855b9

# Copyright (c) 2021 Angus Gratton # # SPDX-License-Identifier: Apache-2.0 # # This module contains device-level interface to Canalyst-II import ctypes import logging import usb.core import time from . import protocol logger = logging.getLogger(__name__) # "Fast" lookups to go from channel to USB endpoint number CHANNEL_TO_COMMAND_EP = [2, 4] # Command EP for channels 0,1 CHANNEL_TO_MESSAGE_EP = [1, 3] # CAN Message EP for channels 0, 1 class CanalystDevice(object): """Encapsulates a low-level USB interface to a Canalyst-II device. Constructing an instance of this class will cause pyusb to acquire the relevant USB interface, and retain it until the object is garbage collected. :param device:_index if more than one Canalyst-II device is connected, this is the index to use in the list. :param usb_device: Optional argument to ignore device_index and provide an instance of a pyusb device object directly. :param bitrate: If set, both channels are initialized to the specified bitrate and started automatically. If unset (default) then the "init" method must be called before using either channel. :param timing0: Optional parameter to provide BTR timing directly. Either both or neither timing0 and timing1 must be set, and setting these arguments is mutually exclusive with setting bitrate. If set, both channels are initialized and started automatically. """ # Small optimization, build common command packet one time COMMAND_MESSAGE_STATUS = protocol.SimpleCommand(protocol.COMMAND_MESSAGE_STATUS) MESSAGE_BUF_LEN = ctypes.sizeof(protocol.MessageBuffer) def __init__( self, device_index=0, usb_device=None, bitrate=None, timing0=None, timing1=None ): """Constructor function.""" if usb_device is not None: self._dev = usb_device else: devices = list( usb.core.find( idVendor=protocol.USB_ID_VENDOR, idProduct=protocol.USB_ID_PRODUCT, find_all=True, ) ) if not devices: raise ValueError("No Canalyst-II USB device found") if len(devices) <= device_index: raise ValueError( f"Can't open device_index {device_index}, only {len(devices)} devices found." ) self._dev = devices[device_index] active_config = self._dev.get_active_configuration() if active_config is None or active_config.bConfigurationValue != 1: self._dev.set_configuration(1) self._initialized = [False, False] self._started = [False, False] # Check this looks like the firmware we expect: as this is an unofficial driver, # we don't know if other versions might are out there. if self._dev.product != "Chuangxin Tech USBCAN/CANalyst-II": logger.warning( f"Unexpected USB product string: {self._dev.product}. Firmware version may be unsupported." ) interfaces = self._dev.get_active_configuration().interfaces() if len(interfaces) != 1: logger.warning( f"Unexpected interface count {len(interfaces)}. Firmware version may be unsupported." ) endpoints = interfaces[0].endpoints() # For whatever reason FW has 6 bidirectional BULK endpoints! if len(endpoints) != 12: logger.warning( f"Unexpected endpoint count {len(endpoints)}. Firmware version mayb e unsupported." ) if bitrate is not None or timing0 is not None: # if not specified, don't initialize yet self.init(0, bitrate, timing0, timing1) self.init(1, bitrate, timing0, timing1) def __del__(self): # In theory pyusb should manage this, but in order to allow a new device # object to be created later (in the same process) it seems the device needs to be reset (which # calls dispose internally) try: self._dev.reset() except AttributeError: pass def clear_rx_buffer(self, channel): """Clears the device's receive buffer for the specified channel. Note that this doesn't seem to 100% work in the device firmware, on a busy bus it's possible to receive a small number of "old" messages even after calling this. :param channel: Channel (0 or 1) to clear the RX buffer on. """ self.send_command( channel, protocol.SimpleCommand(protocol.COMMAND_CLEAR_RX_BUFFER) ) def flush_tx_buffer(self, channel, timeout=0): """Check if all pending messages have left the hardware TX buffer and optionally keep polling until this happens or a timeout is reached. Note that due to hardware limitations, "no messages in TX buffer" doesn't necessarily mean that the messages were sent successfully - for the default send type 0 (see Message.send_type), the hardware will attempt bus arbitration multiple times but if it fails then it will still "send" the message. It also doesn't consider the ACK status of the message. :param channel: Channel (0 or 1) to flush the TX buffer on. :param timeout: Optional number of seconds to continue polling for empty TX buffer. If 0 (default), this function will immediately return the current status of the send buffer. :return: True if flush is successful (no pending messages to send), False if flushing timed out. """ deadline = None while deadline is None or time.time() < deadline: if deadline is None and timeout is not None: deadline = time.time() + timeout resp = self.send_command( channel, self.COMMAND_MESSAGE_STATUS, protocol.MessageStatusResponse, ) if resp.tx_pending == 0: return True return False # timeout! def send_command(self, channel, command_packet, response_class=None): """Low-level function to send a command packet to the channel and optionally wait for a response. :param channel: Channel (0 or 1) to flush the TX buffer on. :param command_packet: Data to send to the channel. Usually this will be a ctypes Structure, but can be anything that supports a bytes buffer interface. :param response_class: If None (default) then this function doesn't expect to read anything back from the device. If not None, should be a ctypes class - 64 bytes will be read into a buffer and returned as an object of this type. """ ep = CHANNEL_TO_COMMAND_EP[channel] self._dev.write(ep, memoryview(command_packet).cast("B")) if response_class: response = self._dev.read(ep | 0x80, 0x40) if len(response) < ctypes.sizeof(response_class): raise RuntimeError( f"Expected response minimum {ctypes.sizeof(response_class)} bytes, got {len(response)} bytes." ) return response_class.from_buffer(response) def init(self, channel, bitrate=None, timing0=None, timing1=None, start=True): """Initialize channel to a particular baud rate. This can be called more than once to change the channel bit rate. :param channel: Channel (0 or 1) to initialize. :param bitrate: Bitrate to set for the channel. Either this argument of both timing0 and timing1 must be set. :param timing0: Raw BTR0 timing value to determine the bitrate. If this argument is set, timing1 must also be set and bitrate argument must be unset. :param timing1: Raw BTR1 timing value to determine the bitrate. If this argument is set, timing0 must also be set and bitrate argument must be unset. :param start: If True (default) then the channel is started after being initialized. If set to False, the channel will not be started until the start function is called manually. """ if bitrate is None and timing0 is None and timing1 is None: raise ValueError( "Either bitrate or both timing0/timing1 parameters are required" ) if bitrate is not None: if timing0 is not None or timing1 is not None: raise ValueError( "If bitrate parameter is set, both timing0 and timing1 parameters should be None" ) try: timing0, timing1 = TIMINGS[bitrate] except KeyError: raise ValueError(f"Bitrate {bitrate} is not supported") if timing0 is None or timing1 is None: raise ValueError( "To set raw timings, both timing0 and timing1 parameters are required" ) init_packet = protocol.InitCommand( command=protocol.COMMAND_INIT, acc_code=0x1, acc_mask=0xFFFFFFFF, filter=0x1, # placeholder timing0=timing0, timing1=timing1, mode=0x0, # placeholder unknown2=0x1, ) # placeholder self.send_command(channel, init_packet) self._initialized[channel] = True self.start(channel) def stop(self, channel): """Stop this channel. CAN messages won't be sent or received on this channel until it is started again. :param channel: Channel (0 or 1) to stop. The channel must already be initialized. """ if not self._initialized[channel]: raise RuntimeError(f"Channel {channel} is not initialized.") self.send_command(channel, protocol.SimpleCommand(protocol.COMMAND_STOP)) self._started[channel] = False def start(self, channel): """Start this channel. This allows CAN messages to be sent and received. The hardware will buffer received messages until the receive() function is called. :param channel: Channel (0 or 1) to start. The channel must already be initialized. """ if not self._initialized[channel]: raise RuntimeError(f"Channel {channel} is not initialized.") self.send_command(channel, protocol.SimpleCommand(protocol.COMMAND_START)) self._started[channel] = True def receive(self, channel): """Poll the hardware for received CAN messages and return them all as a list. :param channel: Channel (0 or 1) to poll. The channel must be started. :return: List of Message objects representing received CAN messages, in order. """ if not self._initialized[channel]: raise RuntimeError(f"Channel {channel} is not initialized.") if not self._started[channel]: raise RuntimeError(f"Channel {channel} is stopped, can't receive messages.") status = self.send_command( channel, self.COMMAND_MESSAGE_STATUS, protocol.MessageStatusResponse ) if status.rx_pending == 0: return [] # Calculate how large our read should be, add one buffer to try and avoid issues # caused by fragmentation (sometimes the RX message is in the next buffer not the # current one) rx_buffer_num = (status.rx_pending + 2) // 3 + 1 rx_buffer_size = rx_buffer_num * self.MESSAGE_BUF_LEN message_ep = CHANNEL_TO_MESSAGE_EP[channel] rx_data = self._dev.read(message_ep | 0x80, rx_buffer_size) assert len(rx_data) % self.MESSAGE_BUF_LEN == 0 num_buffers = len(rx_data) // self.MESSAGE_BUF_LEN # Avoid copying data here, parse the MessageBuffer structures but return # a list of Message objects all pointing into the original USB data # buffer. This is a little wasteful of total RAM but should be faster, # and we assume the caller is going to process these into another format # anyhow. result = [] message_bufs = (protocol.MessageBuffer * num_buffers).from_buffer(rx_data) for buf in message_bufs: count = buf.count assert 0 <= count <= 3 result += buf.messages[:count] return result def send(self, channel, messages, flush_timeout=None): """Send one or more CAN messages to the channel. :param channel: Channel (0 or 1) to send to. The channel must be started. :param messages: Either a single Message object, or a list of Message objects to send. :param flush_timeout: If set, don't return until TX buffer is flushed or timeout is reached. Setting this parameter causes the software to poll the device continuously for the buffer state. If None (default) then the function returns immediately, when some CAN messages may still be waiting to sent due to CAN bus arbitration. See flush_tx_buffer() function for details. :return: None if flush_timeout is None (default). Otherwise True if all messages sent (or failed), False if timeout reached. """ if not self._initialized[channel]: raise RuntimeError(f"Channel {channel} is not initialized.") if not self._started[channel]: raise RuntimeError(f"Channel {channel} is stopped, can't send messages.") if isinstance(messages, protocol.Message): messages = [messages] tx_buffer_num = (len(messages) + 2) // 3 buffers = (protocol.MessageBuffer * tx_buffer_num)() for idx, msg in enumerate(messages): buf_idx = idx // 3 buffers[buf_idx].count += 1 buffers[buf_idx].messages[idx % 3] = msg message_ep = CHANNEL_TO_MESSAGE_EP[channel] self._dev.write(message_ep, memoryview(buffers).cast("B")) if flush_timeout is not None: return self.flush_tx_buffer(channel, flush_timeout) def get_can_status(self, channel): """Return some internal CAN-related values. The actual meaning of these is currently unknown. :return: Instance of the CANStatusResponse structure. Note the field names may not be accurate. """ if not self._initialized[channel]: logger.warning( f"Channel {channel} is not initialized, CAN status may be invalid." ) return self.send_command( channel, protocol.SimpleCommand(protocol.COMMAND_CAN_STATUS), protocol.CANStatusResponse, ) # Lookup from bitrate to Timing0 (BTR0), Timing1 (BTR1) values TIMINGS = { 5000: (0xBF, 0xFF), 10000: (0x31, 0x1C), 20000: (0x18, 0x1C), 33330: (0x09, 0x6F), 40000: (0x87, 0xFF), 50000: (0x09, 0x1C), 66660: (0x04, 0x6F), 80000: (0x83, 0xFF), 83330: (0x03, 0x6F), 100000: (0x04, 0x1C), 125000: (0x03, 0x1C), 200000: (0x81, 0xFA), 250000: (0x01, 0x1C), 400000: (0x80, 0xFA), 500000: (0x00, 0x1C), 666000: (0x80, 0xB6), 800000: (0x00, 0x16), 1000000: (0x00, 0x14), }

f74581304b1ec7afe6efed1c1a84fed53c39ec0a

py

Python

app/celery/process_ses_receipts_tasks.py

alphagov-mirror/notifications-api

4a2e47b118c51f0ad45e87c89521f6087b1fcc2f

app/celery/process_ses_receipts_tasks.py

alphagov-mirror/notifications-api

4a2e47b118c51f0ad45e87c89521f6087b1fcc2f

app/celery/process_ses_receipts_tasks.py

alphagov-mirror/notifications-api

4a2e47b118c51f0ad45e87c89521f6087b1fcc2f

from datetime import datetime, timedelta import iso8601 from celery.exceptions import Retry from flask import current_app, json from notifications_utils.statsd_decorators import statsd from sqlalchemy.orm.exc import NoResultFound from app import notify_celery, statsd_client from app.clients.email.aws_ses import get_aws_responses from app.config import QueueNames from app.dao import notifications_dao from app.models import NOTIFICATION_PENDING, NOTIFICATION_SENDING from app.notifications.notifications_ses_callback import ( _check_and_queue_callback_task, _check_and_queue_complaint_callback_task, determine_notification_bounce_type, handle_complaint, ) @notify_celery.task(bind=True, name="process-ses-result", max_retries=5, default_retry_delay=300) @statsd(namespace="tasks") def process_ses_results(self, response): try: ses_message = json.loads(response['Message']) notification_type = ses_message['notificationType'] bounce_message = None if notification_type == 'Bounce': notification_type, bounce_message = determine_notification_bounce_type(notification_type, ses_message) elif notification_type == 'Complaint': _check_and_queue_complaint_callback_task(*handle_complaint(ses_message)) return True aws_response_dict = get_aws_responses(notification_type) notification_status = aws_response_dict['notification_status'] reference = ses_message['mail']['messageId'] try: notification = notifications_dao.dao_get_notification_or_history_by_reference(reference=reference) except NoResultFound: message_time = iso8601.parse_date(ses_message['mail']['timestamp']).replace(tzinfo=None) if datetime.utcnow() - message_time < timedelta(minutes=5): current_app.logger.info( f"notification not found for reference: {reference} (update to {notification_status}). " f"Callback may have arrived before notification was persisted to the DB. Adding task to retry queue" ) self.retry(queue=QueueNames.RETRY) else: current_app.logger.warning( f"notification not found for reference: {reference} (update to {notification_status})" ) return if bounce_message: current_app.logger.info(f"SES bounce for notification ID {notification.id}: {bounce_message}") if notification.status not in [NOTIFICATION_SENDING, NOTIFICATION_PENDING]: notifications_dao._duplicate_update_warning( notification=notification, status=notification_status ) return else: notifications_dao.dao_update_notifications_by_reference( references=[reference], update_dict={'status': notification_status} ) statsd_client.incr('callback.ses.{}'.format(notification_status)) if notification.sent_at: statsd_client.timing_with_dates('callback.ses.elapsed-time', datetime.utcnow(), notification.sent_at) _check_and_queue_callback_task(notification) return True except Retry: raise except Exception as e: current_app.logger.exception('Error processing SES results: {}'.format(type(e))) self.retry(queue=QueueNames.RETRY)

f745882b7fa076b31cfecf66c9b6f8b109221cd1

py

Python

download_all_fx_data.py

feilongbk/FX-1-Minute-Data

83bd7eaef0dee7221e8acfa980ce180571b6ffce

2017-05-22T07:03:36.000Z

2022-03-31T21:57:21.000Z

download_all_fx_data.py

feilongbk/FX-1-Minute-Data

83bd7eaef0dee7221e8acfa980ce180571b6ffce

2017-12-15T10:30:17.000Z

2021-06-10T01:07:34.000Z

download_all_fx_data.py

feilongbk/FX-1-Minute-Data

83bd7eaef0dee7221e8acfa980ce180571b6ffce

2017-08-07T17:20:48.000Z

2022-03-29T19:46:23.000Z

import csv import os from histdata.api import download_hist_data def mkdir_p(path): import errno try: os.makedirs(path) except OSError as exc: if exc.errno == errno.EEXIST and os.path.isdir(path): pass else: raise def download_all(): with open('pairs.csv', 'r') as f: reader = csv.reader(f, delimiter=',') next(reader, None) # skip the headers for row in reader: currency_pair_name, pair, history_first_trading_month = row year = int(history_first_trading_month[0:4]) print(currency_pair_name) output_folder = os.path.join('output', pair) mkdir_p(output_folder) try: while True: could_download_full_year = False try: print('-', download_hist_data(year=year, pair=pair, output_directory=output_folder, verbose=False)) could_download_full_year = True except AssertionError: pass # lets download it month by month. month = 1 while not could_download_full_year and month <= 12: print('-', download_hist_data(year=str(year), month=str(month), pair=pair, output_directory=output_folder, verbose=False)) month += 1 year += 1 except Exception: print('[DONE] for currency', currency_pair_name) if __name__ == '__main__': download_all()

f7458c30cc2fa802624a2a70a9422c6c7e9ff1a0

py

Python

BioNetGen-2.3.0/source_Atomizer/stats/wordcloud.py

joseph-hellerstein/RuleBasedProgramming

fb88118ab764035979dc7c2bf8c89a7b484e4472

BioNetGen-2.3.0/source_Atomizer/stats/wordcloud.py

joseph-hellerstein/RuleBasedProgramming

fb88118ab764035979dc7c2bf8c89a7b484e4472

BioNetGen-2.3.0/source_Atomizer/stats/wordcloud.py

joseph-hellerstein/RuleBasedProgramming

fb88118ab764035979dc7c2bf8c89a7b484e4472

# -*- coding: utf-8 -*- """ Created on Wed Mar 27 18:06:08 2013 @author: proto """ from pytagcloud import create_tag_image, make_tags from pytagcloud.lang.counter import get_tag_counts def cloudText(text,fileName): tags = make_tags(get_tag_counts(text), maxsize=80) create_tag_image(tags, fileName, size=(800, 600), fontname='Droid Sans')

f7459dd9070c8898f768605d0a670f18c376fd61

py

Python

build/android/run_tests.py

leiferikb/bitpop-private

4c967307d228e86f07f2576068a169e846c833ca

2021-11-15T15:17:43.000Z

2021-11-15T15:17:43.000Z

build/android/run_tests.py

houseoflifeproperty/bitpop-private

4c967307d228e86f07f2576068a169e846c833ca

build/android/run_tests.py

houseoflifeproperty/bitpop-private

4c967307d228e86f07f2576068a169e846c833ca

2020-11-04T07:24:02.000Z

2020-11-04T07:24:02.000Z

#!/usr/bin/env python # # Copyright (c) 2012 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Runs all the native unit tests. 1. Copy over test binary to /data/local on device. 2. Resources: chrome/unit_tests requires resources (chrome.pak and en-US.pak) to be deployed to the device. We use the device's $EXTERNAL_STORAGE as the base dir (which maps to Context.getExternalFilesDir()). 3. Environment: 3.1. chrome/unit_tests requires (via chrome_paths.cc) a directory named: $EXTERNAL_STORAGE + /chrome/test/data 4. Run the binary in the device and stream the log to the host. 4.1. Optionally, filter specific tests. 4.2. If we're running a single test suite and we have multiple devices connected, we'll shard the tests. 5. Clean up the device. Suppressions: Individual tests in a test binary can be suppressed by listing it in the gtest_filter directory in a file of the same name as the test binary, one test per line. Here is an example: $ cat gtest_filter/base_unittests_disabled DataPackTest.Load ReadOnlyFileUtilTest.ContentsEqual This file is generated by the tests running on devices. If running on emulator, additonal filter file which lists the tests only failed in emulator will be loaded. We don't care about the rare testcases which succeeded on emuatlor, but failed on device. """ import copy import fnmatch import logging import optparse import os import signal import subprocess import sys import time import emulator from pylib import android_commands from pylib import buildbot_report from pylib import cmd_helper from pylib import debug_info from pylib import ports from pylib import run_tests_helper from pylib import test_options_parser from pylib.base_test_sharder import BaseTestSharder from pylib.single_test_runner import SingleTestRunner _TEST_SUITES = ['base_unittests', 'cc_unittests', 'content_unittests', 'gpu_unittests', 'ipc_tests', 'media_unittests', 'net_unittests', 'sql_unittests', 'sync_unit_tests', 'ui_unittests', 'unit_tests', 'webkit_compositor_bindings_unittests', ] def FullyQualifiedTestSuites(exe, option_test_suite, build_type): """Get a list of absolute paths to test suite targets. Args: exe: if True, use the executable-based test runner. option_test_suite: the test_suite specified as an option. build_type: 'Release' or 'Debug'. """ test_suite_dir = os.path.join(cmd_helper.OutDirectory.get(), build_type) if option_test_suite: all_test_suites = [option_test_suite] else: all_test_suites = _TEST_SUITES if exe: qualified_test_suites = [os.path.join(test_suite_dir, t) for t in all_test_suites] else: # out/(Debug|Release)/$SUITE_apk/$SUITE-debug.apk qualified_test_suites = [os.path.join(test_suite_dir, t + '_apk', t + '-debug.apk') for t in all_test_suites] for t, q in zip(all_test_suites, qualified_test_suites): if not os.path.exists(q): raise Exception('Test suite %s not found in %s.\n' 'Supported test suites:\n %s\n' 'Ensure it has been built.\n' % (t, q, _TEST_SUITES)) return qualified_test_suites class TimeProfile(object): """Class for simple profiling of action, with logging of cost.""" def __init__(self, description): self._description = description self.Start() def Start(self): self._starttime = time.time() def Stop(self): """Stop profiling and dump a log.""" if self._starttime: stoptime = time.time() logging.info('%fsec to perform %s', stoptime - self._starttime, self._description) self._starttime = None class Xvfb(object): """Class to start and stop Xvfb if relevant. Nop if not Linux.""" def __init__(self): self._pid = 0 def _IsLinux(self): """Return True if on Linux; else False.""" return sys.platform.startswith('linux') def Start(self): """Start Xvfb and set an appropriate DISPLAY environment. Linux only. Copied from tools/code_coverage/coverage_posix.py """ if not self._IsLinux(): return proc = subprocess.Popen(['Xvfb', ':9', '-screen', '0', '1024x768x24', '-ac'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) self._pid = proc.pid if not self._pid: raise Exception('Could not start Xvfb') os.environ['DISPLAY'] = ':9' # Now confirm, giving a chance for it to start if needed. for _ in range(10): proc = subprocess.Popen('xdpyinfo >/dev/null', shell=True) _, retcode = os.waitpid(proc.pid, 0) if retcode == 0: break time.sleep(0.25) if retcode != 0: raise Exception('Could not confirm Xvfb happiness') def Stop(self): """Stop Xvfb if needed. Linux only.""" if self._pid: try: os.kill(self._pid, signal.SIGKILL) except: pass del os.environ['DISPLAY'] self._pid = 0 class TestSharder(BaseTestSharder): """Responsible for sharding the tests on the connected devices.""" def __init__(self, attached_devices, test_suite, gtest_filter, test_arguments, timeout, cleanup_test_files, tool, log_dump_name, fast_and_loose, build_type, in_webkit_checkout): BaseTestSharder.__init__(self, attached_devices, build_type) self.test_suite = test_suite self.test_suite_basename = os.path.basename(test_suite) self.gtest_filter = gtest_filter or '' self.test_arguments = test_arguments self.timeout = timeout self.cleanup_test_files = cleanup_test_files self.tool = tool self.log_dump_name = log_dump_name self.fast_and_loose = fast_and_loose self.in_webkit_checkout = in_webkit_checkout self.all_tests = [] if not self.gtest_filter: # No filter has been specified, let's add all tests then. self.all_tests, self.attached_devices = self._GetAllEnabledTests() self.tests = self.all_tests def _GetAllEnabledTests(self): """Get all enabled tests and available devices. Obtains a list of enabled tests from the test package on the device, then filters it again using the diabled list on the host. Returns: Tuple of (all enabled tests, available devices). Raises Exception if all devices failed. """ # TODO(frankf): This method is doing too much in a non-systematic way. # If the intention is to drop flaky devices, why not go through all devices # instead of breaking on the first succesfull run? available_devices = list(self.attached_devices) while available_devices: try: return (self._GetTestsFromDevice(available_devices[-1]), available_devices) except Exception as e: logging.warning('Failed obtaining tests from %s %s', available_devices[-1], e) available_devices.pop() raise Exception('No device available to get the list of tests.') def _GetTestsFromDevice(self, device): logging.info('Obtaining tests from %s', device) test_runner = SingleTestRunner( device, self.test_suite, self.gtest_filter, self.test_arguments, self.timeout, self.cleanup_test_files, self.tool, 0, not not self.log_dump_name, self.fast_and_loose, self.build_type, self.in_webkit_checkout) # The executable/apk needs to be copied before we can call GetAllTests. test_runner.test_package.StripAndCopyExecutable() all_tests = test_runner.test_package.GetAllTests() disabled_list = test_runner.GetDisabledTests() # Only includes tests that do not have any match in the disabled list. all_tests = filter(lambda t: not any([fnmatch.fnmatch(t, disabled_pattern) for disabled_pattern in disabled_list]), all_tests) return all_tests def CreateShardedTestRunner(self, device, index): """Creates a suite-specific test runner. Args: device: Device serial where this shard will run. index: Index of this device in the pool. Returns: A SingleTestRunner object. """ device_num = len(self.attached_devices) shard_size = (len(self.tests) + device_num - 1) / device_num shard_test_list = self.tests[index * shard_size : (index + 1) * shard_size] test_filter = ':'.join(shard_test_list) + self.gtest_filter return SingleTestRunner( device, self.test_suite, test_filter, self.test_arguments, self.timeout, self.cleanup_test_files, self.tool, index, not not self.log_dump_name, self.fast_and_loose, self.build_type, self.in_webkit_checkout) def OnTestsCompleted(self, test_runners, test_results): """Notifies that we completed the tests.""" test_results.LogFull('Unit test', os.path.basename(self.test_suite), self.build_type, self.all_tests) test_results.PrintAnnotation() if self.log_dump_name: # Zip all debug info outputs into a file named by log_dump_name. debug_info.GTestDebugInfo.ZipAndCleanResults( os.path.join( cmd_helper.OutDirectory.get(), self.build_type, 'debug_info_dumps'), self.log_dump_name) def _RunATestSuite(options): """Run a single test suite. Helper for Dispatch() to allow stop/restart of the emulator across test bundles. If using the emulator, we start it on entry and stop it on exit. Args: options: options for running the tests. Returns: 0 if successful, number of failing tests otherwise. """ step_name = os.path.basename(options.test_suite).replace('-debug.apk', '') buildbot_report.PrintNamedStep(step_name) attached_devices = [] buildbot_emulators = [] if options.use_emulator: for n in range(options.emulator_count): t = TimeProfile('Emulator launch %d' % n) avd_name = None if n > 0: # Creates a temporary AVD for the extra emulators. avd_name = 'run_tests_avd_%d' % n buildbot_emulator = emulator.Emulator(avd_name, options.fast_and_loose) buildbot_emulator.Launch(kill_all_emulators=n == 0) t.Stop() buildbot_emulators.append(buildbot_emulator) attached_devices.append(buildbot_emulator.device) # Wait for all emulators to boot completed. map(lambda buildbot_emulator: buildbot_emulator.ConfirmLaunch(True), buildbot_emulators) elif options.test_device: attached_devices = [options.test_device] else: attached_devices = android_commands.GetAttachedDevices() if not attached_devices: logging.critical('A device must be attached and online.') buildbot_report.PrintError() return 1 # Reset the test port allocation. It's important to do it before starting # to dispatch any tests. if not ports.ResetTestServerPortAllocation(): raise Exception('Failed to reset test server port.') if options.gtest_filter: logging.warning('Sharding is not possible with these configurations.') attached_devices = [attached_devices[0]] sharder = TestSharder( attached_devices, options.test_suite, options.gtest_filter, options.test_arguments, options.timeout, options.cleanup_test_files, options.tool, options.log_dump, options.fast_and_loose, options.build_type, options.webkit) test_results = sharder.RunShardedTests() for buildbot_emulator in buildbot_emulators: buildbot_emulator.Shutdown() return len(test_results.failed) def Dispatch(options): """Dispatches the tests, sharding if possible. If options.use_emulator is True, all tests will be run in new emulator instance. Args: options: options for running the tests. Returns: 0 if successful, number of failing tests otherwise. """ if options.test_suite == 'help': ListTestSuites() return 0 if options.use_xvfb: xvfb = Xvfb() xvfb.Start() all_test_suites = FullyQualifiedTestSuites(options.exe, options.test_suite, options.build_type) failures = 0 for suite in all_test_suites: # Give each test suite its own copy of options. test_options = copy.deepcopy(options) test_options.test_suite = suite failures += _RunATestSuite(test_options) if options.use_xvfb: xvfb.Stop() return failures def ListTestSuites(): """Display a list of available test suites.""" print 'Available test suites are:' for test_suite in _TEST_SUITES: print test_suite def main(argv): option_parser = optparse.OptionParser() test_options_parser.AddTestRunnerOptions(option_parser, default_timeout=0) option_parser.add_option('-s', '--suite', dest='test_suite', help='Executable name of the test suite to run ' '(use -s help to list them)') option_parser.add_option('--out-directory', dest='out_directory', help='Path to the out/ directory, irrespective of ' 'the build type. Only for non-Chromium uses.') option_parser.add_option('-d', '--device', dest='test_device', help='Target device the test suite to run ') option_parser.add_option('-f', '--gtest_filter', dest='gtest_filter', help='gtest filter') option_parser.add_option('-a', '--test_arguments', dest='test_arguments', help='Additional arguments to pass to the test') option_parser.add_option('-L', dest='log_dump', help='file name of log dump, which will be put in ' 'subfolder debug_info_dumps under the same ' 'directory in where the test_suite exists.') option_parser.add_option('-e', '--emulator', dest='use_emulator', action='store_true', help='Run tests in a new instance of emulator') option_parser.add_option('-n', '--emulator_count', type='int', default=1, help='Number of emulators to launch for running the ' 'tests.') option_parser.add_option('-x', '--xvfb', dest='use_xvfb', action='store_true', help='Use Xvfb around tests (ignored if not Linux)') option_parser.add_option('--webkit', action='store_true', help='Run the tests from a WebKit checkout.') option_parser.add_option('--fast', '--fast_and_loose', dest='fast_and_loose', action='store_true', help='Go faster (but be less stable), ' 'for quick testing. Example: when tracking down ' 'tests that hang to add to the disabled list, ' 'there is no need to redeploy the test binary ' 'or data to the device again. ' 'Don\'t use on bots by default!') option_parser.add_option('--repeat', dest='repeat', type='int', default=2, help='Repeat count on test timeout') option_parser.add_option('--exit_code', action='store_true', help='If set, the exit code will be total number ' 'of failures.') option_parser.add_option('--exe', action='store_true', help='If set, use the exe test runner instead of ' 'the APK.') options, args = option_parser.parse_args(argv) if len(args) > 1: print 'Unknown argument:', args[1:] option_parser.print_usage() sys.exit(1) run_tests_helper.SetLogLevel(options.verbose_count) if options.out_directory: cmd_helper.OutDirectory.set(options.out_directory) if options.use_emulator: emulator.DeleteAllTempAVDs() failed_tests_count = Dispatch(options) # Failures of individual test suites are communicated by printing a # STEP_FAILURE message. # Returning a success exit status also prevents the buildbot from incorrectly # marking the last suite as failed if there were failures in other suites in # the batch (this happens because the exit status is a sum of all failures # from all suites, but the buildbot associates the exit status only with the # most recent step). if options.exit_code: return failed_tests_count return 0 if __name__ == '__main__': sys.exit(main(sys.argv))

f745aabe794cc25ba4b2b6225a3914d2e99e5882

py

Python

data/params.py

liulisixin/unsupervised-learning-intrinsic-images

0d4ad151d203885c87122bcc305c787210b28a5c

2018-04-05T21:17:28.000Z

2019-08-10T08:43:58.000Z

data/params.py

liulisixin/unsupervised-learning-intrinsic-images

0d4ad151d203885c87122bcc305c787210b28a5c

2018-07-06T13:38:27.000Z

2019-08-03T09:37:10.000Z

data/params.py

liulisixin/unsupervised-learning-intrinsic-images

0d4ad151d203885c87122bcc305c787210b28a5c

2019-08-13T02:11:54.000Z

2021-07-06T09:27:27.000Z

import copy import json import random import hashlib import numpy as np class IntrinsicParameters(): """ Global parameter values for the algorithm """ def __init__(self): #: if True, print progress to the console self.logging = False #: if True, use a fixed seed for k-means clustering self.fixed_seed = False #: number of iterations for the global loop self.n_iters = 25 #: number of iterations for the dense CRF self.n_crf_iters = 10 #: if ``True``, split clusters at the end self.split_clusters = True #: Pixels k units apart vertically or horizontally are smoothed. #: The paper only uses k=1. self.shading_smooth_k = 1 #: method used to initialize the shading smoothness term: #: "none": omit this term for the first iteration #: "image": use the image itself (intensity channel) #: "constant": constant 0.5 self.shading_blur_init_method = 'none' #: standard deviation for blurring the shading channel self.shading_blur_sigma = 0.1 #: exponent by which the blur size decreases each iteration self.shading_blur_iteration_pow = 1 #: if ``True``, blur in log space. if ``False``, blur in linear #: space and then convert to log. self.shading_blur_log = True #: kmeans initialization: weight given to the intensity channel self.kmeans_intensity_scale = 0.5 #: kmeans initialization: number of clusters (labels) to use self.kmeans_n_clusters = 20 #: kmeans initialization: max pixels to consider at once #: (if the image has more than this, the image is randomly subsampled) self.kmeans_max_samples = 2000000 #: weight of the absolute reflectance prior self.abs_reflectance_weight = 0 #: weight of the absolute shading prior self.abs_shading_weight = 500.0 #: gray-point of absolute shading term self.abs_shading_gray_point = 0.5 #: if ``True``, compute shading error in log space self.abs_shading_log = True #: weight of the shading smoothness unary term self.shading_target_weight = 20000.0 #: norm used to penalize shading smoothness deviations self.shading_target_norm = "L2" #: interpret labels as RGB (intensity with chromaticity), thereby #: penalizing deviations from grayscale in the shading channel (though #: the final answer is always grayscale anyway) self.shading_target_chromaticity = False #: weight of the chromaticity term: each reflectance intensity is #: assigned a chromaticity (from the kmeans initialization) and is #: encouraged to be assigned to image pixels that share the same #: chromaticity. self.chromaticity_weight = 0 #: which norm is used for chromaticity self.chromaticity_norm = "L1" #: compute reflectance distance in log space for the pairwise terms self.pairwise_intensity_log = True #: include chromaticity in pairwise term self.pairwise_intensity_chromaticity = True #: weight of the pairwise term self.pairwise_weight = 10000.0 #: bilateral standard deviation: pairwise pixel distance self.theta_p = 0.1 #: bilateral standard deviation: intensity self.theta_l = 0.12 #: bilateral standard deviation: chromaticity self.theta_c = 0.025 # bilateral standard deviation: Luminance self.theta_L = 0.025 #: if True, keep the median of all intensities fixed in stage 2. This #: doesn't really change much, since the solver is damped anyway. self.stage2_maintain_median_intensity = True #: which norm to use when minimizing shading differences in stage 2 self.stage2_norm = "L1" #: if True, interpret labels as RGB instead of intensity self.stage2_chromaticity = False #: parameters to be saved/loaded ALL_PARAMS = [ 'n_iters', 'n_crf_iters', 'split_clusters', 'kmeans_n_clusters', 'kmeans_max_samples', 'shading_blur_init_method', 'shading_blur_method', 'shading_blur_log', 'shading_blur_sigma', 'shading_blur_bilateral_sigma_range', 'shading_blur_iteration_pow', 'shading_smooth_k', 'kmeans_intensity_scale', 'abs_reflectance_weight', 'abs_shading_log', 'abs_shading_weight', 'abs_shading_gray_point', 'shading_target_weight', 'shading_target_norm', 'shading_target_chromaticity', 'chromaticity_weight', 'chromaticity_norm', 'pairwise_intensity_log', 'pairwise_intensity_chromaticity', 'pairwise_weight', 'theta_p', 'theta_l', 'theta_c', 'stage2_norm', 'stage2_chromaticity', 'stage2_maintain_median_intensity', ] #: parameters to be adjusted during training TRAIN_PARAMS = [ 'n_iters', #'n_crf_iters', 'split_clusters', 'kmeans_intensity_scale', 'kmeans_n_clusters', 'shading_blur_init_method', #'shading_blur_log', #'pairwise_intensity_log', 'shading_blur_sigma', 'shading_smooth_k', 'abs_reflectance_weight', #'abs_shading_log', 'abs_shading_weight', 'abs_shading_gray_point', 'shading_target_weight', 'chromaticity_weight', 'pairwise_weight', 'theta_p', 'theta_l', 'theta_c', ] #: these parameters are discrete 1-of-N choices PARAM_CHOICES = { 'shading_blur_init_method': ( "none", "image", "constant", ), } #: bounds on paramters PARAM_BOUNDS = { 'n_iters': (1, 30), 'n_crf_iters': (1, 10), 'shading_blur_sigma': (1e-8, 1.0), 'shading_smooth_k': (1, 4), 'kmeans_intensity_scale': (1e-8, 1e10), 'kmeans_n_clusters': (2, 50), 'abs_reflectance_weight': (0, 1e10), 'abs_shading_weight': (0, 1e10), 'abs_shading_gray_point': (0, 1e10), 'shading_target_weight': (0, 1e10), 'chromaticity_weight': (0, 1e10), 'pairwise_weight': (0, 1e16), 'theta_p': (1e-8, 1e10), 'theta_l': (1e-8, 1e10), 'theta_c': (1e-8, 1e10), } WEIGHT_PARAMS = [ 'abs_reflectance_weight', 'abs_shading_weight', 'shading_target_weight', 'chromaticity_weight', 'pairwise_weight', ] THETA_PARAMS = [ 'theta_p', 'theta_l', 'theta_c', ] def to_json(self, indent=4, **extra_kwargs): """ Convert paramters to a JSON-encoded string """ obj = {k: getattr(self, k) for k in IntrinsicParameters.ALL_PARAMS} if extra_kwargs: obj.update(extra_kwargs) return json.dumps(obj, sort_keys=True, indent=indent) def __str__(self): return self.to_json() def __unicode__(self): return self.to_json() @staticmethod def from_file(filename): """ Load paramers from ``filename`` (in JSON format) """ return IntrinsicParameters.from_dict(json.load(open(filename))) @staticmethod def from_dict(d): """ Load paramers from a dictionary """ ret = IntrinsicParameters() for k, v in d.iteritems(): if not k.startswith('_') and k not in IntrinsicParameters.ALL_PARAMS: raise ValueError("Invalid parameter: %s" % k) setattr(ret, k, d[k]) return ret def md5(self): dump = self.to_json() m = hashlib.md5() m.update(dump) return m.hexdigest() def save(self, filename, **extra_kwargs): """ Save paramers to ``filename`` (in JSON format) """ with open(filename, 'w') as f: f.write(self.to_json(**extra_kwargs)) def clip(self): """ Clip parameters to be within bounds """ for k, bounds in IntrinsicParameters.PARAM_BOUNDS.iteritems(): v = getattr(self, k) t = type(v) setattr(self, k, t(np.clip(v, bounds[0], bounds[1]))) def random_perterbation( self, mean_num_params=8, std_delta=0.5, seed=None): """ Return a new set of parameters with a random perterbation. The number of variables modified is Poisson-distributed with mean ``mean_num_params`` , and each changed variable is multiplied by exp(x) where x is normally distributed with mean 0 and standard deviation ``std_delta`` """ if seed is not None: random.seed(seed) np.random.seed(seed) # choose a random subset to modify num_params = len(IntrinsicParameters.TRAIN_PARAMS) n = np.clip(np.random.poisson(mean_num_params), 1, num_params) keys = random.sample(IntrinsicParameters.TRAIN_PARAMS, n) # modify the subset ret = copy.deepcopy(self) for k in keys: v = getattr(ret, k) t = type(v) if k in IntrinsicParameters.PARAM_CHOICES: v = random.choice(IntrinsicParameters.PARAM_CHOICES[k]) elif t == bool: v = random.choice((False, True)) else: v *= np.exp(random.normalvariate(0, std_delta)) if t in (int, long): v = round(v) setattr(ret, k, t(v)) ret.clip() return ret

f745c68cb1628be5bb8685f132df4cbb3d3c320f

py

Python

utils/video.py

gosticks/body-pose-animation

eb1b5876a845f277d43bfc18dcd48c4a9c694c06

utils/video.py

gosticks/body-pose-animation

eb1b5876a845f277d43bfc18dcd48c4a9c694c06

utils/video.py

gosticks/body-pose-animation

eb1b5876a845f277d43bfc18dcd48c4a9c694c06

from dataset import SMPLyDataset import pickle from typing import Tuple from model import SMPLyModel from renderer import DefaultRenderer import cv2 from tqdm import tqdm import numpy as np from scipy import interpolate def make_video(images, video_name: str, fps=30, ext: str = "mp4", post_process_frame=None): images = np.array(images) width = images.shape[2] height = images.shape[1] fourcc = 0 if ext == "mp4": fourcc = cv2.VideoWriter_fourcc(*'MP4V') video_name = video_name + "." + ext video = cv2.VideoWriter( video_name, fourcc, fps, (width, height), True) for idx in tqdm(range(len(images))): img = images[idx] im_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) if post_process_frame is not None: img_rgb = post_process_frame(img=im_rgb, idx=idx) video.write(im_rgb) video.release() print("video saved to:", video_name) def video_from_pkl(filename, video_name, config, ext: str = "mp4"): with open(filename, "rb") as fp: model_outs = pickle.load(fp) save_to_video(model_outs, video_name, config) def save_to_video( sample_output: Tuple, video_name: str, config: object, fps=30, include_thumbnail=True, thumbnail_size=0.2, start_frame_offset=0, dataset: SMPLyDataset = None, interpolation_target=None ): """ Renders a video from pose, camera tuples. Additionally interpolation can be used to smooth out the animation Args: sample_output (Tuple): A tuple of body pose vertices and a camera transformation video_name (str): name for the resulting video file (can also be a path) config (object): general run config fps (int, optional): animation base fps. Defaults to 30. interpolation_target (int, optional): expand animation fps via interpolation to this target. Defaults to 60. """ r = DefaultRenderer( offscreen=True ) r.start() model_anim = SMPLyModel.model_from_conf(config) if interpolation_target is not None: if interpolation_target % fps != 0: print("[error] interpolation target must be a multiple of fps") return inter_ratio = int(interpolation_target / fps) num_intermediate = inter_ratio - 1 sample_output = interpolate_poses(sample_output, num_intermediate) else: sample_output = [ ( out.vertices.detach().cpu().numpy()[0], cam ) for out, cam in sample_output] frames = [] print("[export] rendering animation frames...", sample_output[0][0].shape) # just use the first transform cam_transform = sample_output[0][1] for vertices, cam_trans in tqdm(sample_output): r.render_model_geometry( faces=model_anim.faces, vertices=vertices, pose=cam_trans # cam_transform, ) frames.append(r.get_snapshot()) target_fps = fps if interpolation_target is not None: target_fps = interpolation_target def post_process_frame(img, idx: int): if not include_thumbnail: return img # account for start from frames not zero idx = start_frame_offset + idx frame_idx = idx if interpolation_target is not None: # account for possible interpolation frame_idx = int(idx / inter_ratio) img_path = dataset.get_image_path(frame_idx) overlay = cv2.imread(img_path) if overlay is None: print("[error] image could not be ", img_path) return img overlay = cv2.resize( overlay, dsize=( int(overlay.shape[1] * thumbnail_size), int(overlay.shape[0] * thumbnail_size) )) img[0:overlay.shape[0], 0:overlay.shape[1]] = overlay return img make_video(frames, video_name, target_fps, post_process_frame=post_process_frame) def make_video_with_pip(frames, pip_image_path, video_name: str, fps=30, ext: str = "mp4", image_size=0.2): """renders a video with a pip frame in the corner """ def post_process_frame(img, idx: int): overlay = cv2.imread(pip_image_path) if overlay is None: print("[error] image could not be ", pip_image_path) return img overlay = cv2.resize( overlay, dsize=( int(overlay.shape[1] * image_size), int(overlay.shape[0] * image_size) )) img[0:overlay.shape[0], 0:overlay.shape[1]] = overlay return img make_video(frames, video_name, fps, post_process_frame=post_process_frame) def interpolate_poses(poses, num_intermediate=5): """ Interpolate vertices and cameras between pairs of frames by adding intermediate results :param poses: optimized poses :param num_intermediate: amount of intermediate results to insert between each pair of frames :return: interpolated poses, list of tuples (body_pose, camera_pose) """ new_poses = [] for i in range(len(poses) - 1): if len(poses) < 2: return poses else: # Shape of one matrix of vertices = torch.Size([1, 10475, 3]) pose_1 = poses[i][0].vertices.detach().cpu().numpy() pose_2 = poses[i + 1][0].vertices.detach().cpu().numpy() poses_pair = np.concatenate((pose_1, pose_2), axis=0) camera_1 = np.expand_dims(poses[i][1], axis=0) camera_2 = np.expand_dims(poses[i + 1][1], axis=0) camera_pair = np.concatenate((camera_1, camera_2), axis=0) x = np.arange(poses_pair.shape[0]) f1 = interpolate.interp1d(x, poses_pair, axis=0) f2 = interpolate.interp1d(x, camera_pair, axis=0) evenly_spaced_points = np.linspace( x[0], x[-1], (poses_pair.shape[0] - 1) * (num_intermediate + 1) + 1) new_frames = f1(evenly_spaced_points) new_cameras = f2(evenly_spaced_points) arr = [(new_frames[i], new_cameras[i]) for i in range(new_frames.shape[0])] if 0 < i < len(poses) - 1: # remove first frame that was already added in the last interpolation arr.pop(0) new_poses += arr return new_poses

f745d61facecf176819f6e0b1334bf6b5d46de14

py

Python

tests/unittests/test_network_install.py

cloudify-cosmo/cloudify-nsx-plugin

d7b2abbe384e55aaf47b2c8474ab07f622eb83b5

2017-03-08T21:44:54.000Z

2019-01-16T06:00:16.000Z

tests/unittests/test_network_install.py

cloudify-cosmo/cloudify-nsx-plugin

d7b2abbe384e55aaf47b2c8474ab07f622eb83b5

2017-01-26T13:26:31.000Z

2017-02-03T14:51:45.000Z

tests/unittests/test_network_install.py

cloudify-cosmo/cloudify-nsx-plugin

d7b2abbe384e55aaf47b2c8474ab07f622eb83b5

2016-12-28T15:26:02.000Z

2017-01-30T08:46:10.000Z

# Copyright (c) 2017 GigaSpaces Technologies Ltd. All rights reserved # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import unittest import library.test_nsx_base as test_nsx_base import pytest import mock import copy import cloudify_nsx.network.dhcp_bind as dhcp_bind import cloudify_nsx.network.dhcp_pool as dhcp_pool import cloudify_nsx.network.dlr_dgw as dlr_dgw import cloudify_nsx.network.bgp_neighbour_filter as bgp_neighbour_filter import cloudify_nsx.network.esg_firewall as esg_firewall import cloudify_nsx.network.esg_gateway as esg_gateway import cloudify_nsx.network.esg_interface as esg_interface import cloudify_nsx.network.esg_nat as esg_nat import cloudify_nsx.network.dlr_bgp_neighbour as dlr_bgp_neighbour import cloudify_nsx.network.dlr_interface as dlr_interface import cloudify_nsx.network.lswitch as lswitch import cloudify_nsx.network.ospf_area as ospf_area import cloudify_nsx.network.ospf_interface as ospf_interface import cloudify_nsx.network.esg_route as esg_route import cloudify_nsx.network.relay as relay import cloudify_nsx.network.routing_ip_prefix as routing_ip_prefix import cloudify_nsx.network.routing_redistribution as routing_redistribution from cloudify.state import current_ctx class NetworkInstallTest(test_nsx_base.NSXBaseTest): def setUp(self): super(NetworkInstallTest, self).setUp() self._regen_ctx() def tearDown(self): current_ctx.clear() super(NetworkInstallTest, self).tearDown() @pytest.mark.internal @pytest.mark.unit def test_esg_firewall_install(self): """Check create esg firewall rule""" # everything by default self._common_install_create( "esg_id|id", esg_firewall.create, {"rule": {"esg_id": "esg_id", "action": "deny"}}, create_args=['firewallRules'], create_kwargs={ "request_body_dict": { 'firewallRules': { 'firewallRule': { 'direction': None, 'name': None, 'application': None, 'loggingEnabled': 'false', 'matchTranslated': 'false', 'destination': None, 'enabled': 'true', 'source': None, 'action': 'deny' } } }, "uri_parameters": {'edgeId': 'esg_id'} }, create_response=test_nsx_base.SUCCESS_RESPONSE_ID ) # Additional values(non default) self._common_install_create( "other_esg_id|id", esg_firewall.create, {"rule": { "esg_id": "other_esg_id", "action": "accept", 'loggingEnabled': True, 'matchTranslated': True, 'enabled': False, 'ruleTag': 42, 'description': 'Some Rule', 'source': 'any', 'direction': 'in', 'destination': '8.8.8.8', 'name': 'rule' }}, create_args=['firewallRules'], create_kwargs={ "request_body_dict": { 'firewallRules': { 'firewallRule': { 'direction': 'in', 'name': 'rule', 'application': None, 'loggingEnabled': 'true', 'matchTranslated': 'true', 'destination': '8.8.8.8', 'enabled': 'false', 'source': 'any', 'action': 'accept', 'ruleTag': '42', 'description': 'Some Rule' } } }, "uri_parameters": {'edgeId': 'other_esg_id'} }, create_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_esg_interface_install(self): """Check create esg interface""" self._common_install_extract_or_read_and_update( 'id|esg_id', esg_interface.create, {'interface': { "esg_id": "esg_id", "ifindex": "id", "portgroup_id": "portgroup_id" }}, read_args=['vnic'], read_kwargs={ 'uri_parameters': {'index': 'id', 'edgeId': 'esg_id'} }, read_response={ 'status': 204, 'body': test_nsx_base.EDGE_INTERFACE_BEFORE }, update_args=['vnic'], update_kwargs={ 'request_body_dict': test_nsx_base.EDGE_INTERFACE_AFTER, 'uri_parameters': {'index': 'id', 'edgeId': 'esg_id'} }, update_response=test_nsx_base.SUCCESS_RESPONSE ) @pytest.mark.internal @pytest.mark.unit def test_esg_interface_install_all_fields(self): """Check create esg interface""" self._common_install_extract_or_read_and_update( 'id|esg_id', esg_interface.create, {'interface': { "esg_id": "esg_id", "ifindex": "id", "name": "name", "netmask": "255.255.255.0", "ipaddr": "192.168.3.127", "secondary_ips": "192.168.3.128", 'prefixlen': "24", 'enable_send_redirects': 'true', 'is_connected': 'true', 'enable_proxy_arp': 'true', "portgroup_id": "portgroup_id" }}, read_args=['vnic'], read_kwargs={ 'uri_parameters': {'index': 'id', 'edgeId': 'esg_id'} }, read_response={ 'status': 204, 'body': test_nsx_base.EDGE_INTERFACE_BEFORE }, update_args=['vnic'], update_kwargs={ 'request_body_dict': { 'vnic': { 'portgroupId': 'portgroup_id', 'portgroupName': None, 'type': 'internal', 'enableProxyArp': 'true', 'name': 'name', 'addressGroups': { 'addressGroup': { 'secondaryAddresses': { 'ipAddress': '192.168.3.128' }, 'primaryAddress': '192.168.3.127', 'subnetMask': '255.255.255.0', 'subnetPrefixLength': '24' } }, 'isConnected': 'true', 'enableSendRedirects': 'true', 'mtu': 1500 } }, 'uri_parameters': {'index': 'id', 'edgeId': 'esg_id'} }, update_response=test_nsx_base.SUCCESS_RESPONSE ) @pytest.mark.internal @pytest.mark.unit def test_esg_nat_install(self): """Check create esg nat rule""" self._common_install_extract_or_read_and_update( 'esg_id|id', esg_nat.create, {'rule': { "esg_id": "esg_id", "action": "action", "originalAddress": "originalAddress", "translatedAddress": "translatedAddress" }}, extract_args=['edgeNatRules', 'create'], extract_kwargs={}, extract_response={ 'natRules': { 'natRule': {} } }, create_args=['edgeNatRules'], create_kwargs={ 'uri_parameters': {'edgeId': "esg_id"}, 'request_body_dict': test_nsx_base.ESG_NAT_AFTER }, create_response=test_nsx_base.SUCCESS_RESPONSE_ID ) self._common_install_extract_or_read_and_update( 'esg_id|id', esg_nat.create, {'rule': { "esg_id": "esg_id", "action": "action", "originalAddress": "originalAddress", "translatedAddress": "translatedAddress", "description": "3", 'vnic': '1', 'ruleTag': '2', "loggingEnabled": 'true', 'enabled': 'false' }}, extract_args=['edgeNatRules', 'create'], extract_kwargs={}, extract_response={ 'natRules': { 'natRule': {} } }, create_args=['edgeNatRules'], create_kwargs={ 'uri_parameters': {'edgeId': "esg_id"}, 'request_body_dict': { 'natRules': { 'natRule': { 'translatedPort': 'any', 'action': 'action', 'originalAddress': 'originalAddress', 'translatedAddress': 'translatedAddress', 'vnic': '1', 'ruleTag': '2', 'description': '3', 'enabled': 'false', 'protocol': 'any', 'originalPort': 'any', 'loggingEnabled': 'true' } } } }, create_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.unit def test_dlr_bgp_neighbour_dlr_install(self): """Check define dlr bgp neighbour""" self._common_use_existing_without_run( 'some_id', dlr_bgp_neighbour.create_dlr, {'neighbour': {"dlr_id": "dlr_id", "ipAddress": "ipAddress", 'remoteAS': 'remoteAS', 'protocolAddress': 'protocolAddress', 'forwardingAddress': 'forwardingAddress'}}) self._common_install_extract_or_read_and_update( 'dlr_id|ip|remoteAS|protocolIp|forwardingIp', dlr_bgp_neighbour.create_dlr, {'neighbour': {"dlr_id": "dlr_id", "ipAddress": "ip", 'remoteAS': 'remoteAS', 'forwardingAddress': 'forwardingIp', 'protocolAddress': 'protocolIp'}}, read_args=['routingBGP'], read_kwargs={'uri_parameters': {'edgeId': 'dlr_id'}}, read_response={ 'body': test_nsx_base.DLR_BGP_NEIGHBOUR_BEFORE, 'status': 204 }, update_args=['routingBGP'], update_kwargs={ 'request_body_dict': test_nsx_base.DLR_BGP_NEIGHBOUR_AFTER, 'uri_parameters': {'edgeId': 'dlr_id'} }, update_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_dlr_bgp_neighbour_esg_install(self): """Check define esg bgp neighbour""" self._common_use_existing_without_run( 'esg_id|ip|remoteAS||', dlr_bgp_neighbour.create_esg, {'neighbour': {"dlr_id": "dlr_id", "ipAddress": "ipAddress", 'remoteAS': 'remoteAS'}}) self._common_install_extract_or_read_and_update( 'esg_id|ip|remoteAS||', dlr_bgp_neighbour.create_esg, {'neighbour': {"dlr_id": "esg_id", "ipAddress": "ip", 'remoteAS': 'remoteAS'}}, read_args=['routingBGP'], read_kwargs={'uri_parameters': {'edgeId': 'esg_id'}}, read_response={ 'body': test_nsx_base.EDGE_BGP_NEIGHBOUR_BEFORE, 'status': 204 }, update_args=['routingBGP'], update_kwargs={ 'request_body_dict': test_nsx_base.EDGE_BGP_NEIGHBOUR_AFTER, 'uri_parameters': {'edgeId': 'esg_id'} }, update_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_dlr_dgw_install(self): """Check create dlr dgw""" self._common_install_extract_or_read_and_update( 'dlr_id', dlr_dgw.create, {'gateway': {"dlr_id": "dlr_id", "address": "address"}}, extract_args=['routingConfig', 'update'], extract_kwargs={}, extract_response=test_nsx_base.ROUTING_CONFIG_UPDATE_EXTRACT, update_args=['routingConfig'], update_kwargs={ 'uri_parameters': {'edgeId': "dlr_id"}, 'request_body_dict': { 'routing': test_nsx_base.EDG_STATIC_ROUTING_GATEWAY_AFTER } }, update_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_dhcp_pool_install(self): """Check create dhcp pool""" self._common_use_existing_without_run( 'some_id', dhcp_pool.create, {'pool': {'esg_id': 'esg_id', 'ip_range': 'ip_range'}}) self._common_install_create( 'esg_id|id', dhcp_pool.create, {'pool': {'esg_id': 'esg_id', 'ip_range': '192.168.5.128-192.168.5.250', 'default_gateway': '192.168.5.1', 'subnet_mask': '255.255.255.0', 'domain_name': 'internal.test', 'dns_server_1': '8.8.8.8', 'dns_server_2': '192.168.5.1', 'lease_time': 'infinite', 'auto_dns': 'true'}}, create_args=['dhcpPool'], create_kwargs={ 'request_body_dict': { 'ipPool': { 'domainName': 'internal.test', 'leaseTime': 'infinite', 'primaryNameServer': '8.8.8.8', 'secondaryNameServer': '192.168.5.1', 'autoConfigureDNS': 'true', 'subnetMask': '255.255.255.0', 'ipRange': '192.168.5.128-192.168.5.250', 'defaultGateway': '192.168.5.1' } }, 'uri_parameters': {'edgeId': 'esg_id'} }, create_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_dhcp_bind_install(self): """Check insert binding rule to dhcp ip""" self._common_use_existing_without_run( "some_id", dhcp_bind.create, {'bind': {"esg_id": "esg_id", "hostname": "hostname", "ip": "ip"}}) self._common_install( "some_id", dhcp_bind.create, {'bind': {"esg_id": "esg_id", "hostname": "hostname", "ip": "ip"}}) @pytest.mark.internal @pytest.mark.unit def test_dhcp_bind_install_mac(self): """Check insert binding rule to dhcp ip""" self._common_install_create( 'esg_id|id', dhcp_bind.create, {'bind': {'esg_id': 'esg_id', 'mac': '11:22:33:44:55:66', 'hostname': 'secret.server', 'ip': '192.168.5.251', 'default_gateway': '192.168.5.1', 'subnet_mask': '255.255.255.0', 'domain_name': 'secret.internal.test', 'dns_server_1': '8.8.8.8', 'dns_server_2': '192.168.5.1', 'lease_time': 'infinite', 'auto_dns': 'true'}}, create_args=['dhcpStaticBinding'], create_kwargs={ 'request_body_dict': { 'staticBinding': { 'subnetMask': '255.255.255.0', 'domainName': 'secret.internal.test', 'primaryNameServer': '8.8.8.8', 'macAddress': '11:22:33:44:55:66', 'leaseTime': 'infinite', 'secondaryNameServer': '192.168.5.1', 'hostname': 'secret.server', 'defaultGateway': '192.168.5.1', 'ipAddress': '192.168.5.251', 'autoConfigureDNS': 'true' } }, 'uri_parameters': {'edgeId': 'esg_id'} }, create_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_dhcp_bind_install_vm(self): """Check insert binding rule to dhcp ip""" self._common_install_create( 'esg_id|id', dhcp_bind.create, {'bind': {'esg_id': 'esg_id', 'vm_id': 'vm_id', 'vnic_id': 'vnic_id', 'hostname': 'secret.server', 'ip': '192.168.5.251', 'default_gateway': '192.168.5.1', 'subnet_mask': '255.255.255.0', 'domain_name': 'secret.internal.test', 'dns_server_1': '8.8.8.8', 'dns_server_2': '192.168.5.1', 'lease_time': 'infinite', 'auto_dns': 'true'}}, create_args=['dhcpStaticBinding'], create_kwargs={ 'request_body_dict': { 'staticBinding': { 'subnetMask': '255.255.255.0', 'domainName': 'secret.internal.test', 'primaryNameServer': '8.8.8.8', 'vnicId': 'vnic_id', 'vmId': 'vm_id', 'secondaryNameServer': '192.168.5.1', 'hostname': 'secret.server', 'ipAddress': '192.168.5.251', 'defaultGateway': '192.168.5.1', 'leaseTime': 'infinite', 'autoConfigureDNS': 'true' } }, 'uri_parameters': {'edgeId': 'esg_id'} }, create_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_bgp_neighbour_filter_install(self): """Check create bgp_neighbour_filter""" self._common_use_existing_without_run( 'net|esg_id|ip|remoteAS|protocolIp|forwardingIp', bgp_neighbour_filter.create, {'filter': { "neighbour_id": "neighbour_id", "action": "deny", "direction": "in", "network": "network"}}) self._common_install_extract_or_read_and_update( 'net|esg_id|ip|remoteAS|protocolIp|forwardingIp', bgp_neighbour_filter.create, {'filter': { "neighbour_id": "esg_id|ip|remoteAS|protocolIp|forwardingIp", "action": "deny", "direction": "in", "network": "net", "ipPrefixGe": "ipPrefixGe", "ipPrefixLe": "ipPrefixLe" }}, # read read_args=['routingBGP'], read_kwargs={'uri_parameters': {'edgeId': 'esg_id'}}, read_response={ 'body': test_nsx_base.DLR_BGP_NEIGHBOUR_WITH_FILTER_BEFORE, 'status': 204 }, # update update_args=['routingBGP'], update_kwargs={ 'request_body_dict': test_nsx_base.DLR_BGP_NEIGHBOUR_WITH_FILTER_AFTER, 'uri_parameters': {'edgeId': 'esg_id'} }, update_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_dlr_interface_install(self): """Check create dlr interface""" self._common_use_existing_without_run( 'id|dlr_id', dlr_interface.create, {'interface': { "dlr_id": "dlr_id", "interface_ls_id": "interface_ls_id", "interface_ip": "interface_ip", "interface_subnet": "interface_subnet" }}) self._common_install_extract_or_read_and_update( 'id|dlr_id', dlr_interface.create, {'interface': { "dlr_id": "dlr_id", "interface_ls_id": "interface_ls_id", "interface_ip": "interface_ip", "interface_subnet": "interface_subnet" }}, extract_args=['interfaces', 'create'], extract_kwargs={}, extract_response={ 'interfaces': { 'interface': { 'addressGroups': { 'addressGroup': { 'primaryAddress': { } } } } } }, create_args=['interfaces'], create_kwargs={ 'query_parameters_dict': {'action': 'patch'}, 'request_body_dict': test_nsx_base.DLR_INTERFACE_CREATE, 'uri_parameters': {'edgeId': 'dlr_id'} }, create_response={ 'status': 204, 'body': test_nsx_base.DLR_INTERFACE_CREATE_RESPONSE } ) @pytest.mark.internal @pytest.mark.unit def test_lswitch_install(self): """Check create logical swicth""" fake_client, _, kwargs = self._kwargs_regen_client( "id", { "switch": { "name": "name", "transport_zone": "transport_zone" } } ) fake_client.read = mock.Mock( return_value=copy.deepcopy({ 'status': 204, 'body': test_nsx_base.LSWITCH }) ) with mock.patch( 'cloudify_nsx.library.nsx_common.NsxClient', mock.MagicMock(return_value=fake_client) ): lswitch.create(**kwargs) self.assertEqual( self.fake_ctx.instance.runtime_properties['vsphere_network_id'], "some_port_id" ) @pytest.mark.internal @pytest.mark.unit def test_dhcp_relay_install(self): """Check create dhcp relay(dlr)""" self._common_install( "some_id", relay.create, { 'relay': { "dlr_id": "dlr_id" } } ) # without resource_id self._regen_ctx() fake_client, _, kwargs = self._kwargs_regen_client( None, { 'relay': { "dlr_id": "dlr_id" } } ) fake_dlr_esg = mock.Mock() fake_dlr_esg.update_dhcp_relay = mock.MagicMock() with mock.patch( 'cloudify_nsx.library.nsx_common.NsxClient', mock.MagicMock(return_value=fake_client) ): with mock.patch( 'cloudify_nsx.network.relay.cfy_dlr', fake_dlr_esg ): relay.create(**kwargs) fake_dlr_esg.update_dhcp_relay.assert_called_with( fake_client, 'dlr_id', {}, {} ) @pytest.mark.internal @pytest.mark.unit def test_esg_route_install(self): """Check create esg route""" self._common_install_extract_or_read_and_update( "esg_id|network|192.168.3.10", esg_route.create, {'route': {"esg_id": "esg_id", "network": "network", "next_hop": "192.168.3.10"}}, # read read_args=['routingConfigStatic'], read_kwargs={'uri_parameters': {'edgeId': "esg_id"}}, read_response={ 'status': 204, 'body': test_nsx_base.EDG_STATIC_ROUTING_BEFORE }, # update update_args=['routingConfigStatic'], update_kwargs={ 'uri_parameters': {'edgeId': "esg_id"}, 'request_body_dict': { 'staticRouting': { 'staticRoutes': { 'route': [{ 'description': None, 'network': 'network', 'mtu': '1500', 'vnic': None, 'nextHop': "192.168.3.10", 'adminDistance': '1' }] }, 'defaultRoute': { 'vnic': None, 'gatewayAddress': 'address', 'description': None, 'mtu': None } } } }, update_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_esg_gateway_install(self): """Check create esg gateway""" self._common_install_extract_or_read_and_update( "esg_id|dgw_ip", esg_gateway.create, {"gateway": {"esg_id": "esg_id", "dgw_ip": "dgw_ip"}}, # read read_args=['routingConfigStatic'], read_kwargs={'uri_parameters': {'edgeId': "esg_id"}}, read_response={ 'status': 204, 'body': test_nsx_base.EDG_STATIC_ROUTING_BEFORE }, # update update_args=['routingConfigStatic'], update_kwargs={ 'uri_parameters': {'edgeId': "esg_id"}, 'request_body_dict': { 'staticRouting': { 'staticRoutes': {}, 'defaultRoute': { 'mtu': '1500', 'vnic': None, 'adminDistance': '1', 'gatewayAddress': 'dgw_ip' } } } }, update_response=test_nsx_base.SUCCESS_RESPONSE_ID ) @pytest.mark.internal @pytest.mark.unit def test_ospf_interface_install(self): """Check create ospf interface""" self._common_install( "some_id", ospf_interface.create, {'interface': {"dlr_id": "dlr_id", "areaId": "areaId", "vnic": "vnic"}}) @pytest.mark.internal @pytest.mark.unit def test_ospf_area_install(self): """Check create ospf area""" self._common_install( "some_id", ospf_area.create, {"area": {"dlr_id": "dlr_id", "areaId": "areaId", "type": "nssa"}}) @pytest.mark.internal @pytest.mark.unit def test_routing_ip_install(self): """Check create routing ip prefix""" self._common_install( "some_id", routing_ip_prefix.create, { 'prefix': { "dlr_id": "dlr_id", "name": "name", "ipAddress": "ipAddress" } } ) @pytest.mark.internal @pytest.mark.unit def test_routing_redistribution_install(self): """Check create routing redistribution rule""" self._common_install( "some_id", routing_redistribution.create, { 'rule': { "action": "deny", "type": "bgp", "dlr_id": "dlr_id" } } ) if __name__ == '__main__': unittest.main()

f745e6f3a37289bf61f2bd949c9ce1767d1c69a0

py

Python

manage.py

KamarulAdha/DRF-ML

2036ac6b3b3eb593d28ab89c948bf4ad2a4aa6dd

manage.py

KamarulAdha/DRF-ML

2036ac6b3b3eb593d28ab89c948bf4ad2a4aa6dd

manage.py

KamarulAdha/DRF-ML

2036ac6b3b3eb593d28ab89c948bf4ad2a4aa6dd

#!/usr/bin/env python """Django's command-line utility for administrative tasks.""" import os import sys def main(): """Run administrative tasks.""" os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'deploy_ml.settings') try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?" ) from exc execute_from_command_line(sys.argv) if __name__ == '__main__': main()

f745fd33ee13aea7516b847e8a0906cf09e91960

py

Python

PyFunceble/converter/internal_url.py

NeolithEra/PyFunceble

58db861d36224f279a460f4959aaa2e140ce749f

PyFunceble/converter/internal_url.py

NeolithEra/PyFunceble

58db861d36224f279a460f4959aaa2e140ce749f

PyFunceble/converter/internal_url.py

NeolithEra/PyFunceble

58db861d36224f279a460f4959aaa2e140ce749f

""" The tool to check the availability or syntax of domains, IPv4, IPv6 or URL. :: ██████╗ ██╗ ██╗███████╗██╗ ██╗███╗ ██╗ ██████╗███████╗██████╗ ██╗ ███████╗ ██╔══██╗╚██╗ ██╔╝██╔════╝██║ ██║████╗ ██║██╔════╝██╔════╝██╔══██╗██║ ██╔════╝ ██████╔╝ ╚████╔╝ █████╗ ██║ ██║██╔██╗ ██║██║ █████╗ ██████╔╝██║ █████╗ ██╔═══╝ ╚██╔╝ ██╔══╝ ██║ ██║██║╚██╗██║██║ ██╔══╝ ██╔══██╗██║ ██╔══╝ ██║ ██║ ██║ ╚██████╔╝██║ ╚████║╚██████╗███████╗██████╔╝███████╗███████╗ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═════╝╚══════╝╚═════╝ ╚══════╝╚══════╝ Provides a way to convert our internal URL. Author: Nissar Chababy, @funilrys, contactTATAfunilrysTODTODcom Special thanks: https://pyfunceble.github.io/special-thanks.html Contributors: https://pyfunceble.github.io/contributors.html Project link: https://github.com/funilrys/PyFunceble Project documentation: https://pyfunceble.readthedocs.io///en/master/ Project homepage: https://pyfunceble.github.io/ License: :: MIT License Copyright (c) 2017, 2018, 2019, 2020 Nissar Chababy 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. """ from PyFunceble.abstracts import Version from PyFunceble.exceptions import WrongParameterType from .base import ConverterBase class InternalUrl(ConverterBase): """ Converter of the internal URLs. .. note:: The internal URLs are actually the URL that has nothing to do with what we are going to test. They are only relevant for the software itself. :param str data_to_convert: The data to convert """ def __init__(self, data_to_convert): if not isinstance(data_to_convert, str): raise WrongParameterType( f"<data_to_convert> should be {str}, {type(data_to_convert)} given." ) super().__init__(data_to_convert) self.converted_data = self.to_right_url() def to_right_url(self): """ Process the conversion to the right URL. """ if Version.is_local_dev(): return self.data_to_convert.replace("master", "dev") return self.data_to_convert.replace("dev", "master")

f746028ed415eb45b51d72258c9ab10b0953f241

py

Python

rule_based_decision_making.py

QianLabUSC/cognitively-enhanced-decision-framework

1797ddd41edcbfbfafca5b599ff7ab70f5fdc37f

rule_based_decision_making.py

QianLabUSC/cognitively-enhanced-decision-framework

1797ddd41edcbfbfafca5b599ff7ab70f5fdc37f

2021-06-28T15:35:21.000Z

2021-07-01T06:02:57.000Z

rule_based_decision_making.py

QianLabUSC/cognitively-enhanced-decision-framework

1797ddd41edcbfbfafca5b599ff7ab70f5fdc37f

# This FILE is part of multi-legged robot field exploration model # env_wrapper.py - to obtain user interaction data from website # # This programm is explained by roboLAND in university of southern california. # Please notify the source if you use it # # Copyright(c) 2021-2025 Ryoma Liu # Email: 1196075299@qq.com from env_wrapper import * import seaborn as sns import matplotlib.pyplot as plt from scipy import optimize import random import matplotlib.pylab as pylab import numpy as np from PIL import Image from math import * class rule_state_machine: def __init__(self): '''Initial env info and parameters for decision making ''' self.states = ['Initial', 'Exploration', 'Verification'] self.current_state = 0 self.env = ENV() self.hypo_locations = (['No','Feature_low','Feature_middle', 'Feature_high']) self.hypo_location = 0 self.hypo_samples = (['No','Feature_low', 'Feature_middle', 'Feature_high']) self.hypo_sample = 0 self.information_matrix = [] self.accuracy_matrix = [] self.fitting_error_matrix = [] def set_init_hypo(self, hypo_location, hypo_sample): self.hypo_location = hypo_location self.hypo_sample = hypo_sample def choose_initial_template(self): '''choose initial template According to the initial knowledge and hypothesis, human will select a experience data sample distribution Args: self.hypo_location: inital hypo about data location feature self.hypo_sample : initial hypo about data sample feature Returns: change the initial template in env wrapper ''' if(self.hypo_location == 0): location_index = [1,9,13,21] elif(self.hypo_location == 1): location_index = [1,4,7,11,16,21] elif(self.hypo_location == 2): location_index = [1,5,9,12,15,21] elif(self.hypo_location == 3): location_index = [1,6,11,14,17,20] if(self.hypo_sample == 0): sample_index = [3,3,3,3] elif(self.hypo_sample == 1): sample_index = [5,5,3,3,3,3] elif(self.hypo_sample == 2): sample_index = [3,3,5,5,3,3] elif(self.hypo_sample == 3): sample_index = [3,3,3,3,5,5] initial_action = [location_index, sample_index] self.env.initiate_template(initial_action) def handle_information_coverage(self): sample_state = self.env.get_state() sample_loc = np.array(sample_state[0]) sample_number = np.array(sample_state[1]) sort_index = np.argsort(sample_loc) sample_loc = sample_loc[sort_index] sample_number = sample_number[sort_index] unique_index = np.unique(sample_loc, return_index = True) sample_loc = sample_loc[unique_index[1]] sample_number = sample_number[unique_index[1]] sample_state = [sample_loc, sample_number] print(sample_state) self.information_matrix = np.zeros(22) #information matrix in location self.variable_coverage = np.zeros(20) for i in range(len(sample_state[0])): scale = 0.1 * sample_state[1][i] + 1 locs = sample_state[0][i] + 1 self.information_matrix += gauss(locs, scale) # print(self.information_matrix) # print(gauss(locs, scale)) # self.plot_line('cool green', np.linspace(1,22,22), gauss(locs, scale), 'test'+str(i)) # print("coverage_matrix: ", self.information_matrix) mm, erodi = self.env.get_data_state() mm_mean = np.mean(mm, axis=0) mm_nonzero = mm[np.nonzero(mm)] mm_mean_nonzero = mm_mean[np.nonzero(mm_mean)] start = 0 # 区间左端点 number_of_interval = 20 # 区间个数 length = 1 # 区间长度 intervals = {'{}~{}'.format(length*x+start, length*(x+1)+start): 0 for x in range(number_of_interval)} # 生成区间 result = np.array(interval_statistics(mm_nonzero, intervals)) self.variable_coverage = len(result[(np.nonzero(result))])/len(result) result_number = np.linspace(0, 19, 20) variable_information = np.zeros(20) for i in range(len(result_number)): single_converage = gauss_variable(result_number[i] +0.5, result[i]) variable_information += single_converage # feed the variable coverage into the previous belief self.variable_information = variable_information # print(mm_mean_nonzero) # print(sample_state[0]) # p , e = optimize.curve_fit(piecewise_linear_moisture, np.array(sample_state[0])+1, mm_mean_nonzero) # xloc = np.linspace(1, 22, 22) # xmoisture = piecewise_linear_moisture(xloc, *p) # self.mapping_value = [] # for emoisture in xmoisture: # self.mapping_value.append(variable_information[int(emoisture)]) # print(variable_information) # print(self.mapping_value) # plt.plot(xloc,xmoisture ) # plt.show() def handle_information_accuracy(self): accuracy_matrix = [] mm, data_state = self.env.get_data_state() loc_state = self.env.get_state() # error_cost = np.std(data_state, axis=0) for col in range(data_state.shape[1]): if col in loc_state[0]: effective_data = data_state[:,col][np.nonzero(data_state[:,col])] # print(effective_data) median = np.median(effective_data) k1 = 1.4826 mad = k1 * np.median(np.abs(effective_data-median)) lower_limit = median - (3*mad) upper_limit = median + (3*mad) outlier_data_num = (len(effective_data[(effective_data> upper_limit) & (effective_data<lower_limit)])) data_samples = len(effective_data) if(data_samples == 0): total_cost = 0 elif(data_samples > 0): total_cost = 1 - 1/(1+ (data_samples - 0.99)/(3*outlier_data_num + 1)) accuracy_matrix.append(total_cost) else: accuracy_matrix.append(0) self.accuracy_matrix = accuracy_matrix # print('accuracy_matrix: ', self.accuracy_matrix) def handle_feature_point_detection(self): loc_state = self.env.get_state()[0] #print(self.env.get_state()) self.fitting_error_matrix = np.zeros(22) mm, erodi = self.env.get_data_state() mm_mean = np.mean(mm, axis=0) mm_nonzeroindex = (mm_mean != 0) erodi_mean = np.mean(erodi, axis=0) self.loc_index = np.linspace(1,22,22)[mm_nonzeroindex] data_index = mm_mean[mm_nonzeroindex] data_mean = erodi_mean[mm_nonzeroindex] p , e = optimize.curve_fit(piecewise_linear, data_index, data_mean) # print('dfadfaaf', p) xd = np.linspace(0, np.max(data_index), 22) fit_curve = piecewise_linear(xd, *p) fitting_results = piecewise_linear(data_index, *p) self.fitting_results = fitting_results fitting_error = fitting_results - data_mean mm_mean[mm_nonzeroindex] = fitting_error self.data_index = data_index self.fitting_error_matrix[mm_nonzeroindex] = fitting_error # print(data_mean) nonzero_data_mean = data_mean[np.nonzero(data_mean != 0)] rmse_data = (sqrt(np.sum(np.power(nonzero_data_mean, 2))/ np.size(nonzero_data_mean))) # print(rmse_data) self.rmse_data = rmse_data # plt.plot(xd, fit_curve) # plt.plot(data_index, data_mean, "o") # plt.plot(data_index, fitting_results, "*") # #plt.plot(data_index, fitting_error, "+") # plt.show() # plt.savefig('123.png') # find the feature point location array = np.asarray(data_index) idx = (np.abs(array - p[0])).argmin() loc_indx = loc_state[idx] saturation_estimated = int(loc_indx * (p[0]/array[idx])) self.saturation_selection = np.arange(saturation_estimated - 2, saturation_estimated + 3, 1) def confidence_model(self): non_zero_matrix = (self.fitting_error_matrix[np.nonzero (self.fitting_error_matrix != 0)]) rmse = (sqrt(np.sum(np.power(non_zero_matrix, 2))/ np.size(non_zero_matrix))) # print(rmse) # print(self.fitting_error_matrix) # print(non_zero_matrix) whole_rmse_percentage = rmse/self.rmse_data # print(whole_rmse_percentage) confindence = (0.04 - whole_rmse_percentage) * 30 * self.coverage_criteria # print(confindence) def handle_state_judge(self): if(self.current_state == 0): self.current_state = 1 elif(self.current_state == 1): if(np.min(self.accuracy_matrix) > 0.7 and len(self.information_matrix[self.information_matrix > 0.8]) > 15): self.current_state = 2 else: self.current_state = 1 elif(self.current_state == 2): if(len(self.fitting_error_matrix[self.fitting_error_matrix > 0.8]) > 0): self.current_state = 1 elif(): self.current_state = 2 def information_model(self): self.coverage_criteria = (len(self.information_matrix[self.information_matrix > 0.3]) / 22) accuracy_matrix = np.array(self.accuracy_matrix) # print(accuracy_matrix) self.accuracy_criteria = (len(accuracy_matrix[(accuracy_matrix > 0.6) & (accuracy_matrix != 0)]) / len(accuracy_matrix[accuracy_matrix != 0])) # print('accuracy_value:', self.accuracy_criteria) # percentage of locs which the accuracy is lower than 0.6 # print('coverage_value:', self.coverage_criteria) # percentage of locs which the information is lower than 0.8 def take_action(self): if(self.current_state == 0): self.choose_initial_template() elif(self.current_state == 1): action_loc = np.argmin(self.information_matrix) self.env.set_action([action_loc],[3]) accuracy_loc = np.where(self.accuracy_matrix < 0.7) accuracy_samples = np.ones(len(accuracy_loc)) self.env.set_action(accuracy_loc,accuracy_samples) elif(self.current_state == 2): fitting_error_loc = np.where(self.fitting_error_matrix > 0.8) add_loc = [] add_samples = [] current_state = self.env.get_state() for i in fitting_error_loc: if not i+1 in current_state[0]: add_loc.append(i+1) add_samples.append(3) if not i-1 in current_state[0]: add_loc.append(i-1) add_samples.append(3) self.env.set_action(add_loc, add_samples) def plot(self, color, name): myparams = { 'axes.labelsize': '10', 'xtick.labelsize': '10', 'ytick.labelsize': '10', 'lines.linewidth': 1, 'legend.fontsize': '3', 'font.family': 'Times New Roman', 'figure.figsize': '9, 5' #图片尺寸 } pylab.rcParams.update(myparams) #更新自己的设置 # line_styles=['ro-','b^-','gs-','ro--','b^--','gs--'] #线型设置 fig1 = plt.figure(1) a = plt.plot(self.coverage_criteria, self.accuracy_criteria ,marker='o', color=sns.xkcd_rgb[color], markersize=5) plt.legend(loc="lower right") #图例位置 右下角 plt.ylabel('accuracy') plt.xlabel('coverage ') plt.xlim((0, 1.1)) plt.ylim((0, 1.1)) plt.axvline(x=1, c="b", ls="--", lw=1) plt.axhline(y=1, c="b", ls="--", lw=1) plt.savefig(name) #注意.show()操作后会默认打开一个空白fig,此时保存,容易出现保存的为纯白背景,所以请在show()操作前保存fig. # plt.show() def interval_statistics(data, intervals): if len(data) == 0: return for num in data: for interval in intervals: lr = tuple(interval.split('~')) left, right = float(lr[0]), float(lr[1]) if left <= num <= right: intervals[interval] += 1 results = [] for key, value in intervals.items(): #print("%10s" % key, end='') # 借助 end=''可以不换行 # print("%10s" % value, end='') # "%10s" 右对齐 #print('%16s' % '{:.3%}'.format(value * 1.0 / len(data))) results.append(value) return results def piecewise_linear(x, x0, y0, k1): # x<x0 ⇒ lambda x: k1*x + y0 - k1*x0 # x>=x0 ⇒ lambda x: k2*x + y0 - k2*x0 return np.piecewise(x, [x < x0, x >= x0], [lambda x:k1*x + y0-k1*x0, lambda x: y0]) def piecewise_linear_moisture(x, x0, y0, k1, k2): # x<x0 ⇒ lambda x: k1*x + y0 - k1*x0 # x>=x0 ⇒ lambda x: k2*x + y0 - k2*x0 return np.piecewise(x, [x < x0, x >= x0], [lambda x:k1*x + y0-k1*x0, lambda x: k2*x + y0 - k2*x0]) def gauss(mean, scale, x=np.linspace(1,22,22), sigma=1): return scale * np.exp(-np.square(x - mean) / (2 * sigma ** 2)) def gauss_variable(mean, scale, x=np.linspace(0,19,20), sigma=1): return scale * np.exp(-np.square(x - mean) / (2 * sigma ** 2)) if __name__ == "__main__": DM = rule_state_machine() DM.choose_initial_template() # x = np.linspace(1,22,22) # information_matrix = gauss(1,0.1).reshape(22,1) # print(information_matrix) # sns.set() # ax = sns.heatmap(information_matrix, vmin=0, vmax=1) # plt.title('Information Matrix') # plt.savefig("test.png") DM.handle_information_accuracy() DM.handle_information_coverage() DM.information_model() DM.plot('cool green','test') DM.handle_feature_point_detection() DM.confidence_model()

f74624c2e736bef6cbbf662d661e7836effdb8bc

py

Python

zerver/migrations/0015_attachment.py

dehnert/zulip

f5935e81c7cf2f11ff4ccfcd31d2a1061b8d7ff5

2017-07-27T19:49:12.000Z

2017-07-27T19:49:12.000Z

zerver/migrations/0015_attachment.py

dehnert/zulip

f5935e81c7cf2f11ff4ccfcd31d2a1061b8d7ff5

2021-02-08T20:22:36.000Z

2022-03-11T23:22:45.000Z

zerver/migrations/0015_attachment.py

tobby2002/zulip

66e7c455759f9368bae16b9a604cf63f8e3524cd

2021-04-09T05:50:23.000Z

2021-04-09T05:50:23.000Z

# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations import django.utils.timezone from django.conf import settings class Migration(migrations.Migration): dependencies = [ ('zerver', '0014_realm_emoji_url_length'), ] operations = [ migrations.CreateModel( name='Attachment', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('file_name', models.CharField(max_length=100, db_index=True)), ('path_id', models.TextField(db_index=True)), ('create_time', models.DateTimeField(default=django.utils.timezone.now, db_index=True)), ('messages', models.ManyToManyField(to='zerver.Message')), ('owner', models.ForeignKey(to=settings.AUTH_USER_MODEL)), ], ), ]

f74632da87bc118e8ef70accfd01c8d085a9cbd9

py

Python

modspectra/tests/test_spectrum_creation.py

Deech08/modspectra

4af177418f9ac3e1ff30bf99968251ac143a96bc

2020-06-04T13:09:50.000Z

2020-06-04T13:10:03.000Z

modspectra/tests/test_spectrum_creation.py

Deech08/modspectra

4af177418f9ac3e1ff30bf99968251ac143a96bc

2020-10-29T19:55:57.000Z

2020-10-29T19:55:57.000Z

modspectra/tests/test_spectrum_creation.py

Deech08/modspectra

4af177418f9ac3e1ff30bf99968251ac143a96bc

import pytest from numpy.random import randn from numpy.random import random import numpy as np def test_non_detection(): from ..cube import EmissionCube from astropy.coordinates import SkyCoord import astropy.units as u ''' Test that an anti-center pointing returns zero emission ''' l = 180. + randn()*130. b = 0. + randn()*20. while (l > 340.) | (l < 20.): # Ensure actual non-detection l = 180. + randn()*130. c = SkyCoord(l = l*u.deg, b = b*u.deg, frame = 'galactic', galcen_distance = 8.127*u.kpc) spec = EmissionCube.create_DK19_spectrum(c, 0.5 * u.deg, redden = False) assert np.allclose(spec.value, np.zeros_like(spec.value)) def test_coordinate_error(): from ..cube import EmissionCube import astropy.units as u ''' Ensure that a SkyCoord Object is required ''' l = 0. + randn()*5. b = 0. + randn()*3. try: spec = EmissionCube.create_DK19_spectrum((l,b), 0.5 * u.deg, redden = False) except TypeError: assert True else: assert False def test_galcen_distance(): from ..cube import EmissionCube import astropy.units as u from astropy.coordinates import SkyCoord ''' Ensure that a default galcen_distnace is adopted ''' l = 0. + randn()*5. b = 0. + randn()*3. c = SkyCoord(l = l*u.deg, b = b*u.deg, frame = 'galactic') c2 = SkyCoord(l = l*u.deg, b = b*u.deg, frame = 'galactic', galcen_distance = 8.127*u.kpc) spec = EmissionCube.create_DK19_spectrum(c, 0.5 * u.deg, redden = False) spec2 = EmissionCube.create_DK19_spectrum(c2, 0.5 * u.deg, redden = False) assert np.allclose(spec.value, spec2.value) def test_radius_degrees(): from ..cube import EmissionCube import astropy.units as u from astropy.coordinates import SkyCoord ''' Ensure that a default units for radius are in ''' l = 0. + randn()*5. b = 0. + randn()*3. c = SkyCoord(l = l*u.deg, b = b*u.deg, frame = 'galactic', galcen_distance = 8.127*u.kpc) r1 = np.abs( randn()*1000.) * u.arcmin r2 = r1.to(u.deg).value spec = EmissionCube.create_DK19_spectrum(c, r1, redden = False) spec2 = EmissionCube.create_DK19_spectrum(c, r2, redden = False) assert np.allclose(spec.value, spec2.value)

f746c16fea3027a482c679020427437ced86395f

py

Python

examples/camera.py

cloudmesh/cloudmesh.pi

bdf706b3763031341c41b811749064c293e73c14

2017-09-18T00:56:36.000Z

2018-06-01T23:41:23.000Z

examples/camera.py

cloudmesh/cloudmesh-pi

bdf706b3763031341c41b811749064c293e73c14

2018-04-16T18:37:17.000Z

2018-04-16T18:37:17.000Z

examples/camera.py

cloudmesh/cloudmesh.pi

bdf706b3763031341c41b811749064c293e73c14

2017-09-20T11:13:54.000Z

2017-11-30T23:48:37.000Z

### # if you dont have picamera installed run sudo apt-get install python-picamera # and emable camera in raspberrypi configuration # # # this progam uses raspberry pi onboarc camera to capture an image and save it to a file # # wait for 5 seconds # capture the image # save the mage to image.jpg file # # for more information see # https://www.raspberrypi.org/documentation/usage/camera/python/README.md ### import picamera import time camera = picamera.PiCamera() count = 5 while count >0: print "capturing image in : ", count count -= 1 time.sleep(1) camera.capture("image.jpg")

f746ea3097b7b326f2fa01df7c61da4f5e6ea7f9

py

Python

test/test_serialization.py

jkulhanek/torchdata

2e8b9f613a13c74b424651649f317c7b322131d6

test/test_serialization.py

jkulhanek/torchdata

2e8b9f613a13c74b424651649f317c7b322131d6

test/test_serialization.py

jkulhanek/torchdata

2e8b9f613a13c74b424651649f317c7b322131d6

# Copyright (c) Meta Platforms, Inc. and affiliates. # All rights reserved. # # This source code is licensed under the BSD-style license found in the # LICENSE file in the root directory of this source tree. import os import pickle import unittest import warnings from functools import partial from io import StringIO from operator import itemgetter from typing import List import expecttest import torchdata.datapipes.iter as iterdp from _utils._common_utils_for_test import create_temp_dir, create_temp_files from torch.utils.data.datapipes.utils.common import DILL_AVAILABLE from torchdata.datapipes.iter import IterableWrapper from torchdata.datapipes.map import SequenceWrapper if DILL_AVAILABLE: import dill dill.extend(use_dill=False) try: import fsspec except ImportError: fsspec = None try: import iopath except ImportError: iopath = None try: import subprocess import rarfile try: rarfile.tool_setup() subprocess.run(("rar", "-?"), check=True) except (rarfile.RarCannotExec, subprocess.CalledProcessError): rarfile = None except (ModuleNotFoundError, FileNotFoundError): rarfile = None try: import torcharrow import torcharrow.dtypes as dt DTYPE = dt.Struct([dt.Field("Values", dt.int32)]) except ImportError: torcharrow = None dt = None DTYPE = None def _fake_batch_fn(batch): return [d + 1 for d in batch] def _fake_fn_ls(x): return [x, x] def _filepath_fn(name: str, dir) -> str: return os.path.join(dir, os.path.basename(name)) def _filter_by_module_availability(datapipes): filter_set = set() if fsspec is None: filter_set.update([iterdp.FSSpecFileLister, iterdp.FSSpecFileOpener, iterdp.FSSpecSaver]) if iopath is None: filter_set.update([iterdp.IoPathFileLister, iterdp.IoPathFileOpener, iterdp.IoPathSaver]) if rarfile is None: filter_set.update([iterdp.RarArchiveLoader]) if torcharrow is None or not DILL_AVAILABLE: filter_set.update([iterdp.DataFrameMaker, iterdp.ParquetDataFrameLoader]) return [dp for dp in datapipes if dp[0] not in filter_set] class TestIterDataPipeSerialization(expecttest.TestCase): def setUp(self): self.temp_dir = create_temp_dir() self.temp_files = create_temp_files(self.temp_dir) self.temp_sub_dir = create_temp_dir(self.temp_dir.name) self.temp_sub_files = create_temp_files(self.temp_sub_dir, 4, False) def tearDown(self): try: self.temp_sub_dir.cleanup() self.temp_dir.cleanup() except Exception as e: warnings.warn(f"TestIterDataPipeSerialization was not able to cleanup temp dir due to {e}") def _serialization_test_helper(self, datapipe): serialized_dp = pickle.dumps(datapipe) deserialized_dp = pickle.loads(serialized_dp) try: self.assertEqual(list(datapipe), list(deserialized_dp)) except AssertionError as e: print(f"{datapipe} is failing.") raise e def _serialization_dataframe_test_helper(self, datapipe): serialized_dp = pickle.dumps(datapipe) deserialized_dp = pickle.loads(serialized_dp) for df1, df2 in zip(datapipe, deserialized_dp): for exp, act in zip(df1, df2): self.assertEqual(exp, act) def _serialization_test_for_single_dp(self, dp, is_dataframe=False): test_helper_fn = self._serialization_dataframe_test_helper if is_dataframe else self._serialization_test_helper # 1. Testing for serialization before any iteration starts test_helper_fn(dp) # 2. Testing for serialization afterDataPipe is partially read it = iter(dp) _ = next(it) test_helper_fn(dp) # 3. Testing for serialization after DataPipe is fully read _ = list(it) test_helper_fn(dp) def _serialization_test_for_dp_with_children(self, dp1, dp2): # 1. Testing for serialization before any iteration starts self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) # 2. Testing for serialization after DataPipe is partially read it1, it2 = iter(dp1), iter(dp2) _, _ = next(it1), next(it2) self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) # 2.5. Testing for serialization after one child DataPipe is fully read # (Only for DataPipes with children DataPipes) _ = list(it1) # fully read one child self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) # 3. Testing for serialization after DataPipe is fully read _ = list(it2) # fully read the other child self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) def test_serializable(self): picklable_datapipes: List = [ (iterdp.BatchMapper, IterableWrapper([(0, 0), (0, 0), (0, 0), (0, 0)]), (_fake_batch_fn, 2, 1), {}), (iterdp.BucketBatcher, IterableWrapper([0, 0, 0, 0, 0, 0, 0]), (5,), {}), (iterdp.Bz2FileLoader, None, (), {}), ( iterdp.CSVDictParser, IterableWrapper( [("f1", StringIO("Label,1,1\nLabel,2,2\nLabel,3,3")), ("f2", StringIO("L,1,1\r\nL,2,2\r\nL,3,3"))] ), (), {}, ), ( iterdp.CSVParser, IterableWrapper( [("f1", StringIO("Label,1,1\nLabel,2,2\nLabel,3,3")), ("f2", StringIO("L,1,1\r\nL,2,2\r\nL,3,3"))] ), (), {}, ), (iterdp.Cycler, None, (2,), {}), (iterdp.DataFrameMaker, IterableWrapper([(i,) for i in range(3)]), (), {"dtype": DTYPE}), (iterdp.Decompressor, None, (), {}), (iterdp.Enumerator, None, (2,), {}), (iterdp.FlatMapper, None, (_fake_fn_ls,), {}), (iterdp.FSSpecFileLister, ".", (), {}), (iterdp.FSSpecFileOpener, None, (), {}), ( iterdp.FSSpecSaver, IterableWrapper([("1.txt", b"DATA1"), ("2.txt", b"DATA2"), ("3.txt", b"DATA3")]), (), {"mode": "wb", "filepath_fn": partial(_filepath_fn, dir=self.temp_dir.name)}, ), (iterdp.GDriveReader, None, (), {}), (iterdp.HashChecker, None, ({},), {}), (iterdp.Header, None, (3,), {}), (iterdp.HttpReader, None, (), {}), # TODO (ejguan): Deterministic serialization is required # (iterdp.InBatchShuffler, IterableWrapper(range(10)).batch(3), (), {}), (iterdp.InMemoryCacheHolder, None, (), {}), (iterdp.IndexAdder, IterableWrapper([{"a": 1, "b": 2}, {"c": 3, "a": 1}]), ("label",), {}), (iterdp.IoPathFileLister, ".", (), {}), (iterdp.IoPathFileOpener, None, (), {}), ( iterdp.IoPathSaver, IterableWrapper([("1.txt", b"DATA1"), ("2.txt", b"DATA2"), ("3.txt", b"DATA3")]), (), {"mode": "wb", "filepath_fn": partial(_filepath_fn, dir=self.temp_dir.name)}, ), ( iterdp.IterKeyZipper, IterableWrapper([("a", 100), ("b", 200), ("c", 300)]), (IterableWrapper([("a", 1), ("b", 2), ("c", 3)]), itemgetter(0), itemgetter(0)), {}, ), ( iterdp.JsonParser, IterableWrapper( [ ("1.json", StringIO('["fo", {"ba":["baz", null, 1.0, 2]}]')), ("2.json", StringIO('{"__cx__": true, "r": 1, "i": 2}')), ] ), (), {}, ), ( iterdp.LineReader, IterableWrapper( [("file1", StringIO("Line1\nLine2")), ("file2", StringIO("Line2,1\r\nLine2,2\r\nLine2,3"))] ), (), {}, ), ( iterdp.MaxTokenBucketizer, IterableWrapper(["1", "22", "1", "4444", "333", "1", "22", "22", "333"]), (4,), {}, ), ( iterdp.MapKeyZipper, IterableWrapper([("a", 1), ("b", 2), ("c", 3)]), (SequenceWrapper({"a": 100, "b": 200, "c": 300}), itemgetter(0)), {}, ), (iterdp.OnDiskCacheHolder, None, (), {}), (iterdp.OnlineReader, None, (), {}), ( iterdp.ParagraphAggregator, IterableWrapper([("f1", "L1"), ("f1", "L2"), ("f2", "21"), ("f2", "22")]), (), {}, ), (iterdp.ParquetDataFrameLoader, None, (), {"dtype": DTYPE}), (iterdp.RarArchiveLoader, None, (), {}), ( iterdp.Rows2Columnar, IterableWrapper([[{"a": 1}, {"b": 2, "a": 1}], [{"a": 1, "b": 200}, {"c": 3}]]), (), {}, ), (iterdp.SampleMultiplexer, {IterableWrapper([0] * 10): 0.5, IterableWrapper([1] * 10): 0.5}, (), {}), ( iterdp.Saver, IterableWrapper([("1.txt", b"DATA1"), ("2.txt", b"DATA2"), ("3.txt", b"DATA3")]), (), {"mode": "wb", "filepath_fn": partial(_filepath_fn, dir=self.temp_dir.name)}, ), (iterdp.TarArchiveLoader, None, (), {}), (iterdp.TFRecordLoader, None, (), {}), (iterdp.UnZipper, IterableWrapper([(i, i + 10) for i in range(10)]), (), {"sequence_length": 2}), (iterdp.XzFileLoader, None, (), {}), (iterdp.ZipArchiveLoader, None, (), {}), ] picklable_datapipes = _filter_by_module_availability(picklable_datapipes) # Skipping value comparison for these DataPipes # Most of them return streams not comparable by `self.assertEqual` # Others are similar to caching where the outputs depend on other DataPipes dp_skip_comparison = { iterdp.Bz2FileLoader, iterdp.Decompressor, iterdp.FileOpener, iterdp.FSSpecFileOpener, iterdp.GDriveReader, iterdp.IoPathFileOpener, iterdp.HashChecker, iterdp.HttpReader, iterdp.OnDiskCacheHolder, iterdp.OnlineReader, iterdp.ParquetDataFrameLoader, iterdp.SampleMultiplexer, iterdp.RarArchiveLoader, iterdp.TarArchiveLoader, iterdp.TFRecordLoader, iterdp.XzFileLoader, iterdp.ZipArchiveLoader, } # These DataPipes produce multiple DataPipes as outputs and those should be compared dp_compare_children = {iterdp.UnZipper} for dpipe, custom_input, dp_args, dp_kwargs in picklable_datapipes: try: # Creating input (usually a DataPipe) for the specific dpipe being tested if custom_input is None: custom_input = IterableWrapper(range(10)) if dpipe in dp_skip_comparison: # Mke sure they are picklable and loadable (no value comparison) datapipe = dpipe(custom_input, *dp_args, **dp_kwargs) # type: ignore[call-arg] serialized_dp = pickle.dumps(datapipe) _ = pickle.loads(serialized_dp) elif dpipe in dp_compare_children: # DataPipes that have children dp1, dp2 = dpipe(custom_input, *dp_args, **dp_kwargs) # type: ignore[call-arg] self._serialization_test_for_dp_with_children(dp1, dp2) else: # Single DataPipe that requires comparison datapipe = dpipe(custom_input, *dp_args, **dp_kwargs) # type: ignore[call-arg] is_dataframe = issubclass(dpipe, (iterdp.DataFrameMaker, iterdp.ParquetDataFrameLoader)) self._serialization_test_for_single_dp(datapipe, is_dataframe=is_dataframe) except Exception as e: print(f"{dpipe} is failing.") raise e def test_serializable_with_dill(self): """Only for DataPipes that take in a function as argument""" input_dp = IterableWrapper(range(10)) ref_idp = IterableWrapper(range(10)) ref_mdp = SequenceWrapper(range(10)) unpicklable_datapipes: List = [ (iterdp.BatchMapper, (lambda batch: [d + 1 for d in batch], 2), {}), (iterdp.FlatMapper, (lambda x: [x, x],), {}), (iterdp.IterKeyZipper, (ref_idp, lambda x: x, None, True, 100), {}), (iterdp.MapKeyZipper, (ref_mdp, lambda x: x), {}), (iterdp.OnDiskCacheHolder, (lambda x: x,), {}), (iterdp.ParagraphAggregator, (lambda x: x,), {}), ] # Skipping value comparison for these DataPipes dp_skip_comparison = {iterdp.OnDiskCacheHolder, iterdp.ParagraphAggregator} for dpipe, dp_args, dp_kwargs in unpicklable_datapipes: if DILL_AVAILABLE: try: if dpipe in dp_skip_comparison: # Make sure they are picklable/loadable (no value comparison) datapipe = dpipe(input_dp, *dp_args, **dp_kwargs) # type: ignore[call-arg] serialized_dp = dill.dumps(datapipe) _ = dill.loads(serialized_dp) else: datapipe = dpipe(input_dp, *dp_args, **dp_kwargs) # type: ignore[call-arg] self._serialization_test_for_single_dp(datapipe) except Exception as e: print(f"{dpipe} is failing.") raise e else: dp_no_attribute_error = (iterdp.OnDiskCacheHolder,) try: with warnings.catch_warnings(record=True) as wa: datapipe = dpipe(input_dp, *dp_args, **dp_kwargs) # type: ignore[call-arg] self.assertEqual(len(wa), 1) self.assertRegex(str(wa[0].message), r"^Lambda function is not supported for pickle") if isinstance(datapipe, dp_no_attribute_error): _ = pickle.dumps(datapipe) else: with self.assertRaises(AttributeError): _ = pickle.dumps(datapipe) except Exception as e: print(f"{dpipe} is failing.") raise e class TestMapDataPipeSerialization(expecttest.TestCase): def test_serializable(self): pass def test_serializable_with_dill(self): """Only for DataPipes that take in a function as argument""" pass if __name__ == "__main__": unittest.main()

f74722dded4b701ea739cfeabcf1fc83a44f0203

py

Python

mdrsl/rule_generation/association_rule_mining/apyori_impl/mine_mt_rules_from_dataframe_with_apyori.py

joschout/Multi-Directional-Rule-Set-Learning

ef0620b115f4e0fd7fba3e752d238a8020c1ca6b

2020-08-03T19:25:44.000Z

2021-06-27T22:25:55.000Z

mdrsl/rule_generation/association_rule_mining/apyori_impl/mine_mt_rules_from_dataframe_with_apyori.py

joschout/Multi-Directional-Rule-Set-Learning

ef0620b115f4e0fd7fba3e752d238a8020c1ca6b

mdrsl/rule_generation/association_rule_mining/apyori_impl/mine_mt_rules_from_dataframe_with_apyori.py

joschout/Multi-Directional-Rule-Set-Learning

ef0620b115f4e0fd7fba3e752d238a8020c1ca6b

2020-08-07T22:54:28.000Z

2021-02-18T06:11:01.000Z

import random import numpy as np from typing import List, Optional, Dict import pandas as pd import time from mdrsl.rule_generation.association_rule_mining.apyori_impl.mine_mt_rules_from_transactions_with_apyori import ( mine_MCARs_from_transactions_using_apyori) from mdrsl.rule_generation.association_rule_mining.frequent_itemset_mining import ( dataframe_to_list_of_transactions, run_fim_apriori, dataframe_to_list_of_transactions_with_encoding) from mdrsl.data_structures.rules.multi_target_class_association_rule import MCAR def mine_MCARs_from_df_using_apyori(df, min_support: float = 0.1, min_confidence: float = 0.0, min_lift=0.0, max_length=None) -> List[MCAR]: transactions = dataframe_to_list_of_transactions(df) return mine_MCARs_from_transactions_using_apyori( transactions, min_support=min_support, min_confidence=min_confidence, min_lift=min_lift, max_length=max_length) def mine_MCARs_from_df_using_apyori_with_encodings(df, min_support: float = 0.1, min_confidence: float = 0.0, min_lift=0.0, max_length=None) -> List[MCAR]: transactions, item_encoder = dataframe_to_list_of_transactions_with_encoding(df) return mine_MCARs_from_transactions_using_apyori( transactions, min_support=min_support, min_confidence=min_confidence, min_lift=min_lift, max_length=max_length, item_encoder=item_encoder) def mine_MCARs(df, rule_cutoff: int, sample=False, random_seed=None, verbose: bool = True, **top_rules_kwargs) -> List[MCAR]: transactions: List[List[str]] = dataframe_to_list_of_transactions(df) mcars: Optional[List[MCAR]] = _top_rules_MIDS(transactions, target_rule_count=rule_cutoff, verbose=verbose) if mcars is None: raise Exception("no MCARs found as input for MIDS") if len(mcars) > rule_cutoff: if sample: if random_seed is not None: random.seed(random_seed) mcars_subset = random.sample(mcars, rule_cutoff) else: mcars_subset = mcars[:rule_cutoff] else: mcars_subset = mcars return mcars_subset if __name__ == '__main__': df_total = pd.DataFrame({ 'A': np.array([1] * 4, dtype='float32'), 'B': np.array([2] * 4, dtype='float32'), 'C': np.array([3] * 4, dtype='float32'), 'D': np.array([4] * 4, dtype='float32') }) print(df_total) itemsets = dataframe_to_list_of_transactions(df_total) support_threshold = 0.1 dataset_transactions = dataframe_to_list_of_transactions(df_total) # type: List[List[str]] cars = mine_MCARs_from_transactions_using_apyori(dataset_transactions, min_support=support_threshold) for car in cars: print(car) print("---") fim_frequent_itemsets = run_fim_apriori(df_total, support_threshold) print(fim_frequent_itemsets) def _top_rules_MIDS(transactions: List[List[str]], appearance: Optional[Dict] = None, target_rule_count: int = 1000, init_support: float = 0.05, init_confidence: float = 0.5, confidence_step: float = 0.05, support_step: float = 0.05, min_length: int = 2, init_max_length: int = 3, total_timeout: float = 100.0, # max time in seconds max_iterations: int = 30, verbose: bool = True ): """ Function for finding the best n (target_rule_count) rules from transaction list. PROBLEM: how to define 'best'? Iteratively: Search for the rules under the current mining parameters. Check the properties of the found rules. If there is still room for improvement, Then update the mining parameters, STOP if: - max nb of iterations is reached (default: 30). - the current nb of rules is more than the nb of rules we are looking for. - the time out is reach FIND all rules with as constraints: - min_support - min_confidence - max_length Parameters ---------- :param transactions : 2D array of strings, e.g. [["a:=:1", "b:=:3"], ["a:=:4", "b:=:2"]] :param appearance : dict - dictionary specifying rule appearance :param target_rule_count : int - target number of rules to mine :param init_support : float - support from which to start mining :param init_confidence : float - confidence from which to start mining :param confidence_step : float :param support_step : float :param min_length : int - minimum len of rules to mine :param init_max_length : int - maximum len from which to start mining :param total_timeout : float - maximum execution time of the function :param max_iterations : int - maximum iterations to try before stopping execution :param verbose : bool Returns ------- list of mined rules. The rules are not ordered. """ if appearance is None: appearance = {} start_time: float = time.time() # the length of a rule is at most the length of a transaction. (All transactions have the same length.) # max_rule_length_wanted = 10 # MAX_RULE_LEN: int = min(len(transactions[0]), max_rule_length_wanted) MAX_RULE_LEN: int = len(transactions[0]) current_support: float = init_support current_confidence: float = init_confidence current_max_length: int = init_max_length keep_mining: bool = True is_max_length_decreased_due_timeout = False current_iteration = 0 last_rule_count = -1 rules: Optional[List[MCAR]] = None if verbose: print("STARTING top_rules") while keep_mining: current_iteration += 1 if current_iteration > max_iterations: if verbose: print("Max iterations reached") break if verbose: print(f"--- iteration {current_iteration} ---") print((f"Running apriori with setting: " f"confidence={current_confidence}, " f"support={current_support}, " f"min_length={min_length}, " f"max_length={current_max_length}, " f"MAX_RULE_LEN={MAX_RULE_LEN}" )) current_rules: List[MCAR] = mine_MCARs_from_transactions_using_apyori( transactions, min_support=current_support, min_confidence=current_confidence, max_length=current_max_length) # rules_current = fim.arules(transactions, supp=support, conf=conf, mode="o", report="sc", appear=appearance, # zmax=maxlen, zmin=minlen) current_nb_of_rules = len(current_rules) # assign rules = current_rules if verbose: print(f"Rule count: {current_nb_of_rules}, Iteration: {current_iteration}") if current_nb_of_rules >= target_rule_count: keep_mining = False if verbose: print(f"\tTarget rule count satisfied: {target_rule_count}") else: current_execution_time = time.time() - start_time # if timeout limit exceeded if current_execution_time > total_timeout: if verbose: print("Execution time exceeded:", total_timeout) keep_mining = False # if we can still increase our rule length AND # the number of rules found has changed (increased?) since last time AND # there has elif current_max_length < MAX_RULE_LEN and last_rule_count != current_nb_of_rules and not is_max_length_decreased_due_timeout: current_max_length += 1 last_rule_count = current_nb_of_rules if verbose: print(f"\tIncreasing max_length {current_max_length}") # if we can still increase our rule length AND # # we can still increase our support # THEN: # increase our support # increment our max length elif current_max_length < MAX_RULE_LEN and is_max_length_decreased_due_timeout and current_support <= 1 - support_step: current_support += support_step current_max_length += 1 last_rule_count = current_nb_of_rules is_max_length_decreased_due_timeout = False if verbose: print(f"\tIncreasing maxlen to {current_max_length}") print(f"\tIncreasing minsup to {current_support}") # IF we can still decrease our confidence # THEN decrease our confidence elif current_confidence > confidence_step: current_confidence -= confidence_step if verbose: print(f"\tDecreasing confidence to {current_confidence}") else: if verbose: print("\tAll options exhausted") keep_mining = False if verbose: end_of_current_iteration_message = f"--- end iteration {current_iteration} ---" print(end_of_current_iteration_message) print("-" * len(end_of_current_iteration_message)) if verbose: print(f"FINISHED top_rules after {current_iteration} iterations") return rules

f7472b67caaccda28cf0edd2bff43417639ea849

py

Python

facebook_business/test/async_ad_docs.py

pasha-r/facebook-python-ads-sdk

76feadd77baed839516b53297628e7a254c8c3c0

facebook_business/test/async_ad_docs.py

pasha-r/facebook-python-ads-sdk

76feadd77baed839516b53297628e7a254c8c3c0

facebook_business/test/async_ad_docs.py

pasha-r/facebook-python-ads-sdk

76feadd77baed839516b53297628e7a254c8c3c0

2018-09-24T14:04:48.000Z

2018-09-24T14:04:48.000Z

# Copyright 2014 Facebook, Inc. # You are hereby granted a non-exclusive, worldwide, royalty-free license to # use, copy, modify, and distribute this software in source code or binary # form for use in connection with the web services and APIs provided by # Facebook. # As with any software that integrates with the Facebook platform, your use # of this software is subject to the Facebook Developer Principles and # Policies [http://developers.facebook.com/policy/]. This copyright 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. ''' Unit tests for the Python Facebook Ads API SDK. How to run: python -m facebook_business.test.async_ad_docs ''' import sys from facebook_business.asyncapi import FacebookAdsAsyncApi from facebook_business.objects import Insights from facebook_business.test.async_docs_utils import * from facebook_business.utils.httpretries import retry_policy class AdDocsTestCase(AsyncDocsTestCase): def setUp(self): campaign = self.create_campaign(1) adset = self.create_adset(1, campaign) creative = self.create_creative_leads(1) ad = self.create_ad(1, adset, creative) AsyncDocsDataStore.set('ad_id', ad.get_id()) def test_get_insights(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) insights = ad.get_insights(fields=[ Insights.Field.ad_id, Insights.Field.unique_clicks, Insights.Field.impressions, ], params={ 'level': Insights.Level.ad, 'date_preset': Insights.Preset.last_week, }) self.store_response(insights) def test_get_ad_creatives(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) creatives = ad.get_ad_creatives_aio(fields=[AdCreative.Field.name]) self.store_response(creatives) def test_get_targeting_description(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) targeting_desc = ad.get_targeting_description_aio(fields=[ 'targetingsentencelines', ]) self.store_response(targeting_desc) def test_get_keyword_stats(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) keywords = ad.get_keyword_stats_aio() self.store_response(keywords) def test_get_ad_preview(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) ad_preview = ad.get_ad_preview_aio(params={ 'ad_format': 'RIGHT_COLUMN_STANDARD', }) self.store_response(ad_preview) def test_get_reach_estimate(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) reach_estimate = ad.get_reach_estimate_aio() self.store_response(reach_estimate) def test_get_click_tracking_tag(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) tag = ad.get_click_tracking_tag_aio() self.store_response(tag) def test_get_leads(self): ad = Ad(AsyncDocsDataStore.get('ad_id')) leads = ad.get_leads_aio() self.store_response(leads) if __name__ == '__main__': handle = open(AsyncDocsDataStore.get('filename'), 'w') handle.write('') handle.close() try: config_file = open('./autogen_docs_config.json') except IOError: print("No config file found, skipping docs tests") sys.exit() config = json.load(config_file) config_file.close() FacebookAdsAsyncApi.init( config['app_id'], config['app_secret'], config['access_token'], config['adaccount_id'], pool_maxsize=10, max_retries=retry_policy() ) AsyncDocsDataStore.set('adaccount_id', config['adaccount_id']) AsyncDocsDataStore.set('adaccount_id_int', config['adaccount_id_int']) AsyncDocsDataStore.set('business_id', config['business_id']) AsyncDocsDataStore.set('ca_id', config['ca_id']) AsyncDocsDataStore.set('dpa_catalog_id', config['dpa_catalog_id']) AsyncDocsDataStore.set('dpa_set_id', config['dpa_set_id']) AsyncDocsDataStore.set('dpa_feed_id', config['dpa_feed_id']) AsyncDocsDataStore.set('dpa_upload_id', config['dpa_upload_id']) AsyncDocsDataStore.set('as_user_id', config['as_user_id']) AsyncDocsDataStore.set('page_id', config['page_id']) AsyncDocsDataStore.set('pixel_id', config['pixel_id']) unittest.main()

f747350ed2fe7ea42b0ccce6f38156b781455d8b

py

Python

taxamo/models/emailInvoiceIn.py

taxamo/taxamo-python

190bdda68963860c131d2b1e9d31cd88de10d694

2016-03-14T03:59:08.000Z

2020-06-21T07:58:38.000Z

taxamo/models/emailInvoiceIn.py

taxamo/taxamo-python

190bdda68963860c131d2b1e9d31cd88de10d694

2016-03-07T13:41:23.000Z

2017-07-11T13:39:44.000Z

taxamo/models/emailInvoiceIn.py

taxamo/taxamo-python

190bdda68963860c131d2b1e9d31cd88de10d694

2016-01-13T14:32:19.000Z

2021-08-16T11:14:06.000Z

#!/usr/bin/env python """ Copyright 2014-2021 by Taxamo 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. """ class EmailInvoiceIn: """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually.""" def __init__(self): self.swaggerTypes = { 'buyer_email': 'str' } #Email to send the invoice. If not provided, transaction.buyer_email will be used. self.buyer_email = None # str

f7473613deb0766b99315c742b58237acf9fe7aa

py

Python

tests/test_PolyViz.py

kobejohn/polymaze

c7ac6049bef547f032c353c5c50e8ead95954a33

2015-02-09T17:36:36.000Z

2021-06-01T19:58:59.000Z

tests/test_PolyViz.py

kobejohn/polymaze

c7ac6049bef547f032c353c5c50e8ead95954a33

2017-01-12T13:52:07.000Z

2017-01-12T13:52:07.000Z

tests/test_PolyViz.py

kobejohn/polymaze

c7ac6049bef547f032c353c5c50e8ead95954a33

2017-12-07T15:18:19.000Z

2021-06-01T19:59:20.000Z

import unittest from tests.test_PolyGrid import generic_grid from polymaze.polygrid import PolyGrid, PolyViz # silly workaround to allow tests to work in py2 or py3 try: _assertCountEqual = unittest.TestCase.assertCountEqual # py3 from unittest import mock except (AttributeError, ImportError): _assertCountEqual = unittest.TestCase.assertItemsEqual # py2 import mock class TestPolyViz(unittest.TestCase): def test_provides_reference_to_related_grid(self): grid = generic_grid() viz = generic_viz(grid) self.assertIs(viz.grid, grid) def test_can_create_new_part_styles(self): viz = generic_viz() any_name = 'asdf' any_color = (0, 0, 0, 0) # confirm styles don't exist self.assertNotIn(any_name, viz._shape_styles) self.assertNotIn(any_name, viz._edge_styles) # make the new styles viz.new_shape_style(any_name, any_color) viz.new_edge_style(any_name, any_color) # confirm they were added self.assertIn(any_name, viz._shape_styles) self.assertIn(any_name, viz._edge_styles) def test_uses_get_x_style_when_drawing_each_part(self): viz = generic_viz() get_style_names = ('get_shape_style', 'get_edge_style') for get_style_name in get_style_names: with mock.patch.object(viz, get_style_name) as m_getstyle: # make the call try: viz.image() except Exception: pass # it will probably die. that's fine. # confirm that the style was retrieved appropriately self.assertTrue(m_getstyle.called) def test_get_x_style_returns_default_when_part_has_no_style_setting(self): viz = generic_viz(generic_grid(neighborhood_center_index=(0, 0))) edge_default_spec = viz._edge_styles['default'] shape_default_spec = viz._shape_styles['default'] # get one of each type of part shape = next(iter(viz.grid.shapes())) edge = next(iter(viz.grid.edges())) # confirm no style setting self.assertIsNone(shape.viz_style) self.assertIsNone(edge.viz_style) # confirm the lookup matches the specification self.assertIs(viz.get_shape_style(shape), shape_default_spec) self.assertIs(viz.get_edge_style(edge), edge_default_spec) def test_get_x_style_returns_named_style_setting_when_part_has_it(self): viz = generic_viz() # create some named styles shape_style_name = '<<shape>>' edge_style_name = '<<edge>>' any_color = (1, 2, 3, 4) viz.new_shape_style(shape_style_name, color=any_color) viz.new_edge_style(edge_style_name, color=any_color) # apply style to some parts shape = next(iter(viz.grid.shapes())) edge = next(iter(viz.grid.edges())) shape.viz_style = shape_style_name edge.viz_style = edge_style_name # get the style container that should be returned shape_style_spec = viz._shape_styles[shape_style_name] edge_style_spec = viz._edge_styles[edge_style_name] # confirm correct style returned self.assertIs(viz.get_shape_style(shape), shape_style_spec) self.assertIs(viz.get_edge_style(edge), edge_style_spec) def test_image_returns_a_PIL_image(self): viz = generic_viz() im = viz.image() # confirm it has an image method self.assertTrue(hasattr(im, 'crop')) def test_image_returns_None_for_empty_grid(self): # make and confirm an empty grid empty_grid = PolyGrid() self.assertEqual(len(tuple(empty_grid.shapes())), 0) # confirm image is None viz = PolyViz(empty_grid) self.assertIsNone(viz.image()) def generic_viz(grid=None): grid = grid or generic_grid(neighborhood_center_index=(0,0)) return PolyViz(grid)

f74747fd63350079355397ba5d7eb5c20324d9bc

py

Python

app/lib/db_query/tweets/categories.py

MichaelCurrin/twitterverse

9629f848377e4346be833db70f11c593cc0d7b6c

2019-03-22T07:07:41.000Z

2022-01-26T00:57:45.000Z

app/lib/db_query/tweets/categories.py

MichaelCurrin/twitterverse

9629f848377e4346be833db70f11c593cc0d7b6c

2017-07-12T19:49:38.000Z

2020-09-02T10:03:28.000Z

app/lib/db_query/tweets/categories.py

MichaelCurrin/twitterverse

9629f848377e4346be833db70f11c593cc0d7b6c

2017-06-30T07:13:39.000Z

2020-12-04T00:39:12.000Z

""" Category queries application file. """ from lib import database as db def printAvailableCategories(): """ Iterate through Categories in db to print out name and Profile count for each. :return: None """ print(" Category | Profiles") print("-------------------------------+---------") categoryResult = db.Category.select() for i, v in enumerate(categoryResult): print( "{index:3d}. {category:25s} | {profCnt:7,d}".format( index=i + 1, category=v.name, profCnt=v.profiles.count() ) ) print() def printCategoriesAndProfiles(): """ Iterate through Categories in db to print out the name and list of the Profiles in each. :return: None """ for i, cat in enumerate(db.Category.select()): profiles = list(cat.profiles.orderBy("screen_name")) print( "{index:d}. {name:15s} {profCnt:,d} profiles".format( index=i + 1, name=cat.name, profCnt=len(profiles) ) ) for p in profiles: print( " - @{screenName:20} | {name}".format( screenName=p.screenName, name=p.name ) ) print() def printUnassignedProfiles(): """ Iterate through Profiles in db to print out those in no Categories. Output may be very long for large datasets of Profiles. TODO: Add filters such as top N recently created profiles or most followers. And find a way to make this more useful, considering that the influencer category and a specific influencer category could be assigned on fetch_profiles.py running, but it has to be clear that industry is assigned yet. :return: None """ for profileRec in db.Profile.select(orderBy="screen_name"): if not profileRec.categories.count(): print( "@{screenName} | {name} | {followers:,d} followers".format( screenName=profileRec.screenName, name=profileRec.name, followers=profileRec.followersCount, ) ) print(profileRec.getFlatDescription()) print() if __name__ == "__main__": print("Available cateogries") print("====================") printAvailableCategories() print() print("Profiles") print("========") printCategoriesAndProfiles()

f7474971492e22c5b28f459c7bf3ba7e80bfc150

py

Python

example/logo_7_8.py

nikteliy/python-snap7

6f8bcb15ad2494fd95880171b974b001d33a5111

2015-02-25T11:07:09.000Z

2022-03-28T10:03:09.000Z

example/logo_7_8.py

nikteliy/python-snap7

6f8bcb15ad2494fd95880171b974b001d33a5111

2015-02-24T18:10:13.000Z

2022-03-22T11:10:09.000Z

example/logo_7_8.py

nikteliy/python-snap7

6f8bcb15ad2494fd95880171b974b001d33a5111

2015-02-24T16:12:32.000Z

2022-03-30T08:50:29.000Z

import logging import snap7 # for setup the Logo connection please follow this link # http://snap7.sourceforge.net/logo.html logging.basicConfig(level=logging.INFO) # Siemens LOGO devices Logo 8 is the default Logo_7 = True logger = logging.getLogger(__name__) plc = snap7.logo.Logo() plc.connect("192.168.0.41",0x1000,0x2000) if plc.get_connected(): logger.info("connected") # read I1 from logo vm_address = ("V923.0" if Logo_7==True else "V1024.0") print (f"I1: {str(plc.read(vm_address))}") # write some values in VM addresses between 0 and 100 value_1 = 0b10110001 value_2 = 480 print("write 0b10110001 to V10") plc.write("V10", value_1) print(f"read V10.0 must be 1 - check: {str(plc.read('V10.0'))}") print(f"read V10.3 must be 0 - check: {str(plc.read('V10.3'))}") print(f"read V10.7 must be 1 - check: {str(plc.read('V10.7'))}") print("write 480 analog value to VW20") plc.write("VW20", value_2) print(f"read VW20 must be 480 - check: {str(plc.read('VW20'))}") print("trigger V10.2") plc.write("V10.2", 0) plc.write("V10.2", 1) plc.write("V10.2", 0) else: logger.error("Conncetion failed") plc.disconnect() logger.info("Disconnected") plc.destroy()

f74766b394c7478c0db1c7e117d71d7afe454999

py

Python

supplychainpy/distribution/air_frieght_transport.py

luisccalves/supplychainpy

63a10b77ffdcc5bca71e815c70667c819d8f9af0

2016-05-30T02:34:45.000Z

2022-03-28T17:00:29.000Z

supplychainpy/distribution/air_frieght_transport.py

luisccalves/supplychainpy

63a10b77ffdcc5bca71e815c70667c819d8f9af0

2016-03-23T16:28:34.000Z

2021-09-30T22:08:03.000Z

supplychainpy/distribution/air_frieght_transport.py

luisccalves/supplychainpy

63a10b77ffdcc5bca71e815c70667c819d8f9af0

2016-08-10T19:53:09.000Z

2022-03-16T16:34:38.000Z

class FreightPlane: def __init__(self): pass

f747a897d8e129afaee76919be306a14ed4c5791

py

Python

elit/datasets/ner/resume.py

emorynlp/levi-graph-amr-parser

f71f1056c13181b8db31d6136451fb8d57114819

2021-07-12T22:05:47.000Z

2022-02-22T03:10:14.000Z

elit/datasets/ner/resume.py

emorynlp/stem-cell-hypothesis

48a628093d93d653865fbac6409d179cddd99293

2021-08-31T08:28:37.000Z

2022-03-28T05:52:14.000Z

elit/datasets/ner/resume.py

emorynlp/stem-cell-hypothesis

48a628093d93d653865fbac6409d179cddd99293

# -*- coding:utf-8 -*- # Author: hankcs # Date: 2020-06-08 12:10 from elit.common.dataset import TransformableDataset from elit.utils.io_util import get_resource, generate_words_tags_from_tsv _RESUME_NER_HOME = 'https://github.com/jiesutd/LatticeLSTM/archive/master.zip#' RESUME_NER_TRAIN = _RESUME_NER_HOME + 'ResumeNER/train.char.bmes' '''Training set of Resume in char level.''' RESUME_NER_DEV = _RESUME_NER_HOME + 'ResumeNER/dev.char.bmes' '''Dev set of Resume in char level.''' RESUME_NER_TEST = _RESUME_NER_HOME + 'ResumeNER/test.char.bmes' '''Test set of Resume in char level.'''

f747bac6efbe42e2ea3d1d195eebcc5275b5d013

py

Python

PythonProjects/10-Sequences/src/m7_summary.py

much2mutch/csse120-public

4f862a6deb7a5373fb5723fb2a23e4042e4d4157

PythonProjects/10-Sequences/src/m7_summary.py

much2mutch/csse120-public

4f862a6deb7a5373fb5723fb2a23e4042e4d4157

PythonProjects/10-Sequences/src/m7_summary.py

much2mutch/csse120-public

4f862a6deb7a5373fb5723fb2a23e4042e4d4157

""" This module lets you practice two forms of the ACCUMULATOR pattern: -- SUMMING -- COUNTING where the accumulation is done via ITERATING (i.e., looping) through a SEQUENCE. It also demonstrates the distinction between: -- an INDEX of the sequence (e.g., -5 is at index 1 in [0, -5, 12, -6]) and -- the item AT an index (e.g., the item at index 3 in [0, -5, 12, -6] is -6). Authors: David Mutchler, Vibha Alangar, Matt Boutell, Dave Fisher, Mark Hays, Amanda Stouder, Derek Whitley, their colleagues, and Seth Mutchler. """ # DONE: 1. PUT YOUR NAME IN THE ABOVE LINE. import testing_helper import time def main(): """ Calls the TEST functions in this module. """ run_test_summary1a() run_test_summary1c() run_test_summary1c() ############################################################################### # DONE: 2. READ the green doc-string for the: # - is_prime # function defined below. You do NOT need to understand its # implementation, just its specification (per the doc-string). # You should ** CALL ** this function as needed in implementing the # other functions. After you have READ this, change its _TODO_ to DONE. ############################################################################### def is_prime(n): """ What comes in: An integer n >= 2. What goes out: -- Returns True if the given integer is prime, else returns False. Side effects: None. Examples: -- is_prime(11) returns True -- is_prime(12) returns False -- is_prime(2) returns True Note: The algorithm used here is simple and clear but slow. """ for k in range(2, (n // 2) + 1): if n % k == 0: return False return True # ------------------------------------------------------------------------- # Students: # Do NOT touch the above is_prime function - it has no _TODO_. # Do NOT copy code from this function. # # Instead, ** CALL ** this function as needed in the problems below. # ------------------------------------------------------------------------- def run_test_summary1a(): """ Tests the summary1a function. """ print() print('--------------------------------------------------') print('Testing the summary1a function:') print('--------------------------------------------------') format_string = ' summary1a( {} )' test_results = [0, 0] # Number of tests passed, failed. # Test 1: expected = 4 sequence = (20, 23, 29, 30, 33, 29, 100, 2, 4) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 2: expected = 4 sequence = (23, 29, 30, 33, 29, 100, 2) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 3: expected = 3 sequence = (20, 29, 30, 33, 29, 100, 100, 99, 40, 30, 30, 2) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 4: expected = 3 sequence = (29, 29, 30, 33, 29, 100, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 5: expected = 2 sequence = (30, 33, 29, 17, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 6: expected = 1 sequence = (30, 33, 13, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 7: expected = 0 sequence = (30, 33, 4, 10, 21, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 8: expected = 3 sequence = (5, 3, 3) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 9: expected = 2 sequence = (5, 3) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 10: expected = 1 sequence = (5,) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 11: expected = 0 sequence = () print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1a(sequence) print_actual_result_of_test(expected, actual, test_results) print_summary_of_test_results(test_results) def summary1a(sequence): """ What comes in: A sequence of integers, all >= 2. What goes out: -- Returns the number of items in the sequence that are prime. Side effects: None. Examples: -- If the given sequence is [20, 23, 29, 30, 33, 29, 100, 2, 4], then the returned value is 4, since 23, 29, 29, and 2 are the 4 primes in the sequence. """ count = 0 for k in range(len(sequence)): if is_prime(sequence[k]): count += 1 return count # ------------------------------------------------------------------------- # DONE: 3. Implement and test this function. # ------------------------------------------------------------------------- def run_test_summary1b(): """ Tests the summary1b function. """ print() print('--------------------------------------------------') print('Testing the summary1b function:') print('--------------------------------------------------') format_string = ' summary1b( {} )' test_results = [0, 0] # Number of tests passed, failed. # Test 1: expected = 83 sequence = (20, 23, 29, 30, 33, 29, 100, 2, 4) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 2: expected = 83 sequence = (23, 29, 30, 33, 29, 100, 2) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 3: expected = 60 sequence = (20, 29, 30, 33, 29, 100, 100, 99, 40, 30, 30, 2) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 4: expected = 87 sequence = (29, 29, 30, 33, 29, 100, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 5: expected = 46 sequence = (30, 33, 29, 17, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 6: expected = 13 sequence = (30, 33, 13, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 7: expected = 0 sequence = (30, 33, 4, 10, 21, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 8: expected = 11 sequence = (5, 3, 3) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 9: expected = 8 sequence = (5, 3) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 10: expected = 5 sequence = (5,) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 11: expected = 0 sequence = () print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1b(sequence) print_actual_result_of_test(expected, actual, test_results) print_summary_of_test_results(test_results) def summary1b(seq): """ What comes in: A sequence of integers, all >= 2. What goes out: -- Returns the sum of items in the sequence that are prime. Side effects: None. Examples: -- If the given sequence is [20, 23, 29, 30, 33, 29, 100, 2, 4], then the returned value is 83, since the primes in the sequence are 23, 29, 29, and 2, and 23 + 29 + 29 + 2 = 83. """ total = 0 for k in range(len(sequence)): if is_prime(sequence[k]): total += sequence[k] return total # ------------------------------------------------------------------------- # DONE: 4. Implement and test this function. # ------------------------------------------------------------------------- def run_test_summary1c(): """ Tests the summary1c function. """ print() print('--------------------------------------------------') print('Testing the summary1c function:') print('--------------------------------------------------') format_string = ' summary1c( {} )' test_results = [0, 0] # Number of tests passed, failed. # Test 1: expected = 1 + 2 + 5 + 7 # which is 15 sequence = (20, 23, 29, 30, 33, 29, 100, 2, 4) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 2: expected = 1 + 4 + 6 # which is 11 sequence = (23, 29, 30, 33, 29, 100, 2) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 3: expected = 16 sequence = (20, 29, 30, 33, 29, 100, 100, 99, 40, 30, 30, 2) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 4: expected = 5 sequence = (29, 29, 30, 33, 29, 100, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 5: expected = 5 sequence = (30, 33, 29, 17, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 6: expected = 2 sequence = (30, 33, 13, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 7: expected = 0 sequence = (30, 33, 4, 10, 21, 100, 99, 40, 30, 30) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 8: expected = 3 sequence = (5, 3, 3) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 9: expected = 1 sequence = (5, 3) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 10: expected = 0 sequence = (5,) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 11: expected = 0 sequence = () print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) # Test 12: expected = 0 sequence = (4,) print_expected_result_of_test([sequence], expected, test_results, format_string) actual = summary1c(sequence) print_actual_result_of_test(expected, actual, test_results) print_summary_of_test_results(test_results) def summary1c(sequence): """ What comes in: A sequence of integers, all >= 2. What goes out: -- Returns the sum of INDICES of the items in the sequence that are prime. Side effects: None. Examples: -- If the given sequence is [20, 23, 29, 30, 33, 29, 100, 2, 4], then the returned value is 15, since the primes in the sequence are at INDICES 1, 2, 5 and 7, and 1 + 2 + 5 + 7 = 15. """ total = 0 for k in range(len(sequence)): if is_prime(sequence[k]): total += k return total # ------------------------------------------------------------------------- # DONE: 5. Implement and test this function. # ------------------------------------------------------------------------- ############################################################################### # Our tests use the following to print error messages in red. # Do NOT change it. You do NOT have to do anything with it. ############################################################################### def print_expected_result_of_test(arguments, expected, test_results, format_string, suffix=''): testing_helper.print_expected_result_of_test(arguments, expected, test_results, format_string, suffix) def print_actual_result_of_test(expected, actual, test_results, precision=None): testing_helper.print_actual_result_of_test(expected, actual, test_results, precision) def print_summary_of_test_results(test_results): testing_helper.print_summary_of_test_results(test_results) # To allow color-coding the output to the console: USE_COLORING = True # Change to False to revert to OLD style coloring testing_helper.USE_COLORING = USE_COLORING if USE_COLORING: # noinspection PyShadowingBuiltins print = testing_helper.print_colored else: # noinspection PyShadowingBuiltins print = testing_helper.print_uncolored # ----------------------------------------------------------------------------- # Calls main to start the ball rolling. # The try .. except prevents error messages on the console from being # intermingled with ordinary output to the console. # ----------------------------------------------------------------------------- try: main() except Exception: print('ERROR - While running this test,', color='red') print('your code raised the following exception:', color='red') print() time.sleep(1) raise

f747cb701495e98da0898401c18ec0d5e5c58ba6

py

Python

src/rubrix/sdk/models/text_classification_annotation.py

sakares/rubrix

791ffb29815b5d24f2bbbb0fa422f85f8b30098f

src/rubrix/sdk/models/text_classification_annotation.py

sakares/rubrix

791ffb29815b5d24f2bbbb0fa422f85f8b30098f

src/rubrix/sdk/models/text_classification_annotation.py

sakares/rubrix

791ffb29815b5d24f2bbbb0fa422f85f8b30098f

# coding=utf-8 # Copyright 2021-present, the Recognai S.L. team. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import Any, Dict, List, Type, TypeVar import attr from ..models.class_prediction import ClassPrediction T = TypeVar("T", bound="TextClassificationAnnotation") @attr.s(auto_attribs=True) class TextClassificationAnnotation: """Annotation class for text classification tasks Attributes: ----------- labels: List[LabelPrediction] list of annotated labels with score""" agent: str labels: List[ClassPrediction] additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) def to_dict(self) -> Dict[str, Any]: agent = self.agent labels = [] for labels_item_data in self.labels: labels_item = labels_item_data.to_dict() labels.append(labels_item) field_dict: Dict[str, Any] = {} field_dict.update(self.additional_properties) field_dict.update( { "agent": agent, "labels": labels, } ) return field_dict @classmethod def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: d = src_dict.copy() agent = d.pop("agent") labels = [] _labels = d.pop("labels") for labels_item_data in _labels: labels_item = ClassPrediction.from_dict(labels_item_data) labels.append(labels_item) text_classification_annotation = cls( agent=agent, labels=labels, ) text_classification_annotation.additional_properties = d return text_classification_annotation @property def additional_keys(self) -> List[str]: return list(self.additional_properties.keys()) def __getitem__(self, key: str) -> Any: return self.additional_properties[key] def __setitem__(self, key: str, value: Any) -> None: self.additional_properties[key] = value def __delitem__(self, key: str) -> None: del self.additional_properties[key] def __contains__(self, key: str) -> bool: return key in self.additional_properties

f747ee58f7f28242455511b3daf96f42202e3d2e

py

Python

src/wai/annotations/adams/base/component/__init__.py

waikato-ufdl/wai-annotations-adams

1cb1ecf9520eea43c392a07d7766da51551a3a20

src/wai/annotations/adams/base/component/__init__.py

waikato-ufdl/wai-annotations-adams

1cb1ecf9520eea43c392a07d7766da51551a3a20

src/wai/annotations/adams/base/component/__init__.py

waikato-ufdl/wai-annotations-adams

1cb1ecf9520eea43c392a07d7766da51551a3a20

from ._ADAMSBaseReader import ADAMSBaseReader from ._ADAMSBaseWriter import ADAMSBaseWriter from ._ADAMSFilenameSource import ADAMSFilenameSource

f74815e8fe1acf0580d8f6e57bd76d58194451ce

py

Python

dvc/ignore.py

amisev/dvc

025de9aeb509a539d5560f82caf47e851162f4a2

dvc/ignore.py

amisev/dvc

025de9aeb509a539d5560f82caf47e851162f4a2

dvc/ignore.py

amisev/dvc

025de9aeb509a539d5560f82caf47e851162f4a2

from __future__ import unicode_literals import os from dulwich.ignore import match_pattern, read_ignore_patterns from dvc.utils import relpath from dvc.utils.compat import cast_bytes from dvc.utils.fs import get_parent_dirs_up_to class DvcIgnoreFileHandler(object): def __init__(self, tree): self.tree = tree def read_patterns(self, path): with self.tree.open(path, binary=True) as stream: return self._read_patterns(stream) def get_repo_root(self): return self.tree.tree_root def _read_patterns(self, binary_stream): negate_patterns = [] patterns = [] for pattern in read_ignore_patterns(binary_stream): if pattern.lstrip().startswith(b"!"): negate_patterns.append(pattern) else: patterns.append(pattern) return negate_patterns, patterns class DvcIgnore(object): DVCIGNORE_FILE = ".dvcignore" def __call__(self, root, dirs, files): raise NotImplementedError class DvcIgnoreFromFile(DvcIgnore): def __init__(self, ignore_file_path, ignore_handler): self.ignore_file_path = ignore_file_path self.dirname = os.path.normpath(os.path.dirname(ignore_file_path)) self.patterns = [] self.negate_patterns = [] self.negate_patterns, self.patterns = ignore_handler.read_patterns( ignore_file_path ) def __call__(self, root, dirs, files): files = [f for f in files if not self.matches(root, f)] dirs = [d for d in dirs if not self.matches(root, d)] return dirs, files def get_match(self, abs_path): relative_path = relpath(abs_path, self.dirname) if os.name == "nt": relative_path = relative_path.replace("\\", "/") relative_path = cast_bytes(relative_path, "utf-8") for pattern in self.patterns: if match_pattern( relative_path, pattern ) and self._no_negate_pattern_matches(relative_path): return (abs_path, pattern, self.ignore_file_path) return None def matches(self, dirname, basename): if self.get_match(os.path.join(dirname, basename)): return True return False def _no_negate_pattern_matches(self, path): return all([not match_pattern(path, p) for p in self.negate_patterns]) def __hash__(self): return hash(self.ignore_file_path) class DvcIgnoreConstant(DvcIgnore): def __init__(self, basename): self.basename = basename class DvcIgnoreDir(DvcIgnoreConstant): def __call__(self, root, dirs, files): dirs = [d for d in dirs if not d == self.basename] return dirs, files class DvcIgnoreFile(DvcIgnoreConstant): def __call__(self, root, dirs, files): files = [f for f in files if not f == self.basename] return dirs, files class DvcIgnoreFilter(object): def __init__(self, wdir, ignore_file_handler=None): self.ignores = [ DvcIgnoreDir(".git"), DvcIgnoreDir(".hg"), DvcIgnoreDir(".dvc"), DvcIgnoreFile(".dvcignore"), ] self.ignore_file_handler = ignore_file_handler self._process_ignores_in_parent_dirs(wdir) def _process_ignores_in_parent_dirs(self, wdir): if self.ignore_file_handler: wdir = os.path.normpath(os.path.abspath(wdir)) ignore_search_end_dir = self.ignore_file_handler.get_repo_root() parent_dirs = get_parent_dirs_up_to(wdir, ignore_search_end_dir) for d in parent_dirs: self.update(d) def update(self, wdir): ignore_file_path = os.path.join(wdir, DvcIgnore.DVCIGNORE_FILE) if os.path.exists(ignore_file_path): file_ignore = DvcIgnoreFromFile( ignore_file_path, ignore_handler=self.ignore_file_handler ) self.ignores.append(file_ignore) def __call__(self, root, dirs, files): if self.ignore_file_handler: self.update(root) for ignore in self.ignores: dirs, files = ignore(root, dirs, files) return dirs, files

f7481d7406370b2904206924837783a64d080c67

py

Python

python_solutions/CHAIN_INSPECTION/CHAIN_INSPECTION.py

joelstanner/codeeval

ef0591fabcad39d45f10287d7a1330f342ab96e0

python_solutions/CHAIN_INSPECTION/CHAIN_INSPECTION.py

joelstanner/codeeval

ef0591fabcad39d45f10287d7a1330f342ab96e0

python_solutions/CHAIN_INSPECTION/CHAIN_INSPECTION.py

joelstanner/codeeval

ef0591fabcad39d45f10287d7a1330f342ab96e0

""" CHAIN INSPECTION. https://www.codeeval.com/open_challenges/119/ We use special generator to produce chains of elements. Don't ask why we need them, we're not sure that somebody knows the answer for this question. A chain is represented by a string of name-address pairs. So the first element is the name of a pair and the second one (address) is pointing to the name of a next pair. E.g. BEGIN-3;4-2;3-4;2-END # GOOD 77-END;BEGIN-8;8-11;11-77 # GOOD In examples above we can pass trough the chains from the 'BEGIN' to the 'END' without missing any single pair. In the first case we moved from 'BEGIN' to 3, from 3 to 4, from 4 to 2, from 2 to 'END'. In the second case we moved from 'BEGIN' to 8, from 8 to 11, from 11 to 77, from 77 to 'END'. Our generator was producing only good chains, but something went wrong and now it generates random chains and we are not sure if it's a good chain or a bad one. E.g. BEGIN-3;4-3;3-4;2-END # BAD 77-END;BEGIN-8;8-77;11-11 # BAD In the first case the 'END' is unreachable because we have a loop between 3 and 4. In the second case we can reach the 'END' but we missed one pair (11-11). We know that for a BAD chain the generator first produces a GOOD chain but after that it may replace existing address in some pairs with an address from another pair. It never replaces an address in a pair to an addresses which isn't present in original chain. You can help us by writing a program that investigates the input and finds GOOD and BAD chains. INPUT SAMPLE: Your program should accept as its first argument a path to a filename. Each string in this file is a chain. The pairs are separating by semicolon, the names and the address are separating by dash. E.g. 4-2;BEGIN-3;3-4;2-END 4-2;BEGIN-3;3-4;2-3 OUTPUT SAMPLE: For each line of input print out the chain status. E.g. GOOD BAD Constraints: The number of pairs in a chain is in range [1, 500] The addresses are integers in range [2, 10000] ------------------------------------------------------- process: Read a line from the input file split the chain parts into pairs create a dictionary of chain connections determine if chain is good or bad: Trace from BEGIN Find END Detect loops Detect missed chain links """ from sys import argv def make_links(line): """Split a line into parts, return a dictionary of chain links.""" link_parts = line.split(";") chain_dict = { k: v for k, v in tuple([x.split('-') for x in link_parts]) } return chain_dict def inspect_chain(chain): """Return whether a chain is 'GOOD' or 'BAD'.""" next_key = chain.pop('BEGIN') while True: try: next_key = chain.pop(next_key) if next_key == "END": break except KeyError: return "BAD" if len(chain) > 0: return "BAD" return "GOOD" def main(input_file): """Run the process as described in the challenge description.""" with open(input_file, "r") as file: for line in file: line = line.rstrip() # split the chain parts into pairs # create a dictionary of chain connections links = make_links(line) chain_state = inspect_chain(links) print(chain_state) if __name__ == "__main__": main(argv[1])

f748235b03a77e379a62b710d47f8a964a8cfeba

py

Python

domain-messages/domain_messages/LFMMarketResult/lfmmarketresult.py

simcesplatform/static-time-series-resource-forecaster

0f53915d7fe6da543f628487c8e643f2e9bb2652

domain-messages/domain_messages/LFMMarketResult/lfmmarketresult.py

simcesplatform/static-time-series-resource-forecaster

0f53915d7fe6da543f628487c8e643f2e9bb2652

domain-messages/domain_messages/LFMMarketResult/lfmmarketresult.py

simcesplatform/static-time-series-resource-forecaster

0f53915d7fe6da543f628487c8e643f2e9bb2652

# -*- coding: utf-8 -*- # Copyright 2021 Tampere University and VTT Technical Research Centre of Finland # This software was developed as a part of the ProCemPlus project: https://www.senecc.fi/projects/procemplus # This source code is licensed under the MIT license. See LICENSE in the repository root directory. # Author(s): Amir Safdarian <amir.safdarian@vtt.fi> # Kalle Ruuth (TAU) <kalle.ruuth@tuni.fi> # Keski-Koukkari Antti <antti.keski-koukkari@vtt.fi> # Md Tanjimuddin <md.tanjimuddin@tuni.fi> # Olli Suominen <olli.suominen@tuni.fi> # Otto Hylli <otto.hylli@tuni.fi> # Tanjim <tanjim0023@gmail.com> # Ville Heikkilä <ville.heikkila@tuni.fi> # Ville Mörsky (TAU) <ville.morsky@tuni.fi> """This module contains the message class for the simulation platform LFMMarketResult messages.""" from __future__ import annotations from typing import Union, Dict, Any, List from tools.exceptions.messages import MessageValueError from tools.message.abstract import AbstractResultMessage from tools.tools import FullLogger import datetime from tools.datetime_tools import to_iso_format_datetime_string from tools.message.block import QuantityBlock, TimeSeriesBlock LOGGER = FullLogger(__name__) # Example: # TimeSeriesBlock for RealPower: # # time_tmp = datetime.datetime.now() # time_index_list = [to_iso_format_datetime_string(time_tmp), # to_iso_format_datetime_string(time_tmp + datetime.timedelta(hours=1))] # time_series_block_tmp = TimeSeriesBlock(time_index_list, # {"Regulation": ValueArrayBlock([2.0, 3.0], # "kW")}) # # newMessage2 = LFMMarketResultMessage(**{ # "Type": "LFMMarketResult", # "SimulationId": to_iso_format_datetime_string(datetime.datetime.now()), # "SourceProcessId": "source1", # "MessageId": "messageid1", # "EpochNumber": 1, # "TriggeringMessageIds": ["messageid1.1", "messageid1.2"], # "ActivationTime": to_iso_format_datetime_string(datetime.datetime.now()), # "Duration": 1.0, # "Direction": "upregulation", # "RealPower": time_series_block_tmp, # "Price": 2.0, # "CongestionId": "congestionId1", # "OfferId": "offerid1", # "ResultCount": 1, # "CustomerIds": ["Customer1", "Customer2"] # }) # # NOTE! - ResultCount is only value that requires a value # Others can be left out or set to None (outside what AbstractResultMessage requires) # Use this if ResultCount == 0 # (No checks on this) class LFMMarketResultMessage(AbstractResultMessage): """Class containing all the attributes for an LFMMarketResult message.""" # message type for these messages CLASS_MESSAGE_TYPE = "LFMMarketResult" MESSAGE_TYPE_CHECK = True # Mapping from message JSON attributes to class attributes MESSAGE_ATTRIBUTES = { "ActivationTime": "activation_time", "Duration": "duration", "Direction": "direction", "RealPower": "real_power", "Price": "price", "CongestionId": "congestion_id", "OfferId": "offer_id", "ResultCount": "result_count", "CustomerIds": "customerids" } OPTIONAL_ATTRIBUTES = [] # Values accepted for direction ALLOWED_DIRECTION_VALUES = ["upregulation", "downregulation"] # Units accepted for price ALLOWED_PRICE_UNIT = "EUR" # RealPower units: REAL_POWER_UNIT = "kW" # Attribute names ATTRIBUTE_REALPOWER = "RealPower" ATTRIBUTE_PRICE = "Price" ATTRIBUTE_DURATION = "Duration" # attributes whose value should be a QuantityBlock and the expected unit of measure. QUANTITY_BLOCK_ATTRIBUTES = { ATTRIBUTE_DURATION: "Minute", ATTRIBUTE_PRICE: "EUR" } # attributes whose value should be a Array Block. QUANTITY_ARRAY_BLOCK_ATTRIBUTES = {} # attributes whose value should be a Timeseries Block. TIMESERIES_BLOCK_ATTRIBUTES = [ATTRIBUTE_REALPOWER] MESSAGE_ATTRIBUTES_FULL = { **AbstractResultMessage.MESSAGE_ATTRIBUTES_FULL, **MESSAGE_ATTRIBUTES } OPTIONAL_ATTRIBUTES_FULL = AbstractResultMessage.OPTIONAL_ATTRIBUTES_FULL + OPTIONAL_ATTRIBUTES QUANTITY_BLOCK_ATTRIBUTES_FULL = { **AbstractResultMessage.QUANTITY_BLOCK_ATTRIBUTES_FULL, **QUANTITY_BLOCK_ATTRIBUTES } QUANTITY_ARRAY_BLOCK_ATTRIBUTES_FULL = { **AbstractResultMessage.QUANTITY_ARRAY_BLOCK_ATTRIBUTES_FULL, **QUANTITY_ARRAY_BLOCK_ATTRIBUTES } TIMESERIES_BLOCK_ATTRIBUTES_FULL = ( AbstractResultMessage.TIMESERIES_BLOCK_ATTRIBUTES_FULL + TIMESERIES_BLOCK_ATTRIBUTES ) def __eq__(self, other: Any) -> bool: """Check that two LFMMarketResultMessages represent the same message.""" return ( super().__eq__(other) and isinstance(other, LFMMarketResultMessage) and self.activation_time == other.activation_time and self.duration == other.duration and self.direction == other.direction and self.real_power == other.real_power and self.price == other.price and self.congestion_id == other.congestion_id and self.offer_id == other.offer_id and self.result_count == other.result_count and self.customerids == other.customerids ) @property def activation_time(self) -> Union[str, None]: """The activation time in ISO 8601 format""" return self.__activation_time @activation_time.setter def activation_time(self, activation_time: Union[None, str, datetime.datetime]): if activation_time is None: self.__activation_time = activation_time return if self._check_activation_time(activation_time): iso_format_string = to_iso_format_datetime_string(activation_time) if isinstance(iso_format_string, str): self.__activation_time = iso_format_string return raise MessageValueError("'{:s}' is an invalid ActivationTime".format(str(activation_time))) @classmethod def _check_activation_time(cls, activation_time: Union[None, str, datetime.datetime]) -> bool: return activation_time is None or cls._check_datetime(activation_time) @property def duration(self) -> Union[QuantityBlock, None]: """The duration of the request""" return self.__duration @duration.setter def duration(self, duration: Union[str, float, int, Dict[str, Any], QuantityBlock, None]): if isinstance(duration, int): duration = float(duration) if self._check_duration(duration): self._set_quantity_block_value(self.ATTRIBUTE_DURATION, duration) return raise MessageValueError("'{:s}' is an invalid value for {}.".format( str(duration), self.ATTRIBUTE_DURATION)) @classmethod def _check_duration(cls, duration: Union[str, float, int, Dict[str, Any], QuantityBlock, None]) -> bool: return cls._check_quantity_block( value=duration, unit=cls.QUANTITY_BLOCK_ATTRIBUTES_FULL[cls.ATTRIBUTE_DURATION], can_be_none=True, float_value_check=lambda value: value >= 0.0 ) @property def direction(self) -> Union[str, None]: """The direction of the request""" return self.__direction @direction.setter def direction(self, direction: Union[str, None]): if self._check_direction(direction): self.__direction = direction return raise MessageValueError("'{:s}' is an invalid value for Direction".format(str(direction))) @classmethod def _check_direction(cls, direction: Union[str, None]) -> bool: if direction is None or (isinstance(direction, str) and direction in cls.ALLOWED_DIRECTION_VALUES): return True return False @property def real_power(self) -> Union[TimeSeriesBlock, None]: """Offered regulation as a TimeSeriesBlock""" return self.__real_power @real_power.setter def real_power(self, real_power: Union[TimeSeriesBlock, Dict[str, Any], None]): if self._check_real_power(real_power): self._set_timeseries_block_value(self.ATTRIBUTE_REALPOWER, real_power) return raise MessageValueError("'{:s}' is an invalid value for {}".format(str(real_power), self.ATTRIBUTE_REALPOWER)) @classmethod def _check_real_power(cls, real_power: Union[TimeSeriesBlock, Dict[str, Any], None]) -> bool: return cls._check_timeseries_block(value=real_power, can_be_none=True, block_check=cls._check_real_power_block) @classmethod def _check_real_power_block(cls, real_power_block: TimeSeriesBlock) -> bool: block_series = real_power_block.series if len(block_series) < 1 or len(real_power_block.time_index) < 1: return False for value_array in block_series.values(): if value_array.unit_of_measure != cls.REAL_POWER_UNIT: return False return True @property def price(self) -> Union[QuantityBlock, None]: """ Price of the offered regulation. Units EUR """ return self.__price @price.setter def price(self, price: Union[str, float, int, QuantityBlock, None]): """ Sets the price for the offer. Sets the input price to a QuantityBlock. If the price is given as a QuantityBlock, uses its unit of measure. """ if isinstance(price, int): price = float(price) if self._check_price(price): self._set_quantity_block_value(message_attribute=self.ATTRIBUTE_PRICE, quantity_value=price) if isinstance(price, QuantityBlock) and isinstance(self.__price, QuantityBlock): self.__price.unit_of_measure = price.unit_of_measure return raise MessageValueError("'{:s}' is an invalid value for {}".format(str(price), self.ATTRIBUTE_PRICE)) @classmethod def _check_price(cls, price) -> bool: if isinstance(price, QuantityBlock): if price.unit_of_measure is not cls.ALLOWED_PRICE_UNIT: return False return cls._check_quantity_block(value=price.value, unit=price.unit_of_measure, can_be_none=True, float_value_check=lambda value: value >= 0.0) return cls._check_quantity_block(value=price, unit=cls.ALLOWED_PRICE_UNIT, can_be_none=True, float_value_check=lambda value: value >= 0.0) @property def congestion_id(self) -> Union[str, None]: """Identifier for the congestion area / specific congestion problem""" return self.__congestion_id @congestion_id.setter def congestion_id(self, congestion_id: Union[str, None]): if self._check_congestion_id(congestion_id): self.__congestion_id = congestion_id return raise MessageValueError("'{:s}' is an invalid value for CongestionId".format(str(congestion_id))) @classmethod def _check_congestion_id(cls, congestion_id: Union[str, None]) -> bool: return congestion_id is None or (isinstance(congestion_id, str) and len(congestion_id) > 0) @property def offer_id(self) -> Union[str, None]: """Identifier for this specific offer""" return self.__offer_id @offer_id.setter def offer_id(self, offer_id: Union[str, None]): if self._check_offer_id(offer_id): self.__offer_id = offer_id return raise MessageValueError("'{:s}' is an invalid value for OfferId".format(str(offer_id))) @classmethod def _check_offer_id(cls, offer_id: Union[str, None]) -> bool: return offer_id is None or (isinstance(offer_id, str) and len(offer_id) > 0) @property def result_count(self) -> int: """ Total number of accepted offers in place the provider is going to send to the running epoch related to this congestion id. """ return self.__result_count @result_count.setter def result_count(self, result_count: Union[str, float, int]): if self._check_result_count(result_count): self.__result_count = int(result_count) return raise MessageValueError("'{:s}' is an invalid value for ResultCount".format(str(result_count))) @classmethod def _check_result_count(cls, result_count: Union[str, float, int]) -> bool: if result_count is None or not isinstance(result_count, (str, float, int)): return False if isinstance(result_count, str): try: result_count = float(result_count) except ValueError: return False return result_count >= 0 and (isinstance(result_count, int) or result_count.is_integer()) @property def customerids(self) -> Union[List[str], None]: return self.__customerids @customerids.setter def customerids(self, customerids: Union[List[str], None]): if self._check_customerids(customerids): self.__customerids = customerids return raise MessageValueError("'{:s}' is an invalid value for CustomerIds".format(str(customerids))) @classmethod def _check_customerids(cls, customerids: Union[List[str], None]) -> bool: if customerids is None: return True if isinstance(customerids, list): if len(customerids) > 0: for customer in customerids: if not isinstance(customer, str): return False return True return False @classmethod def from_json(cls, json_message: Dict[str, Any]) -> Union[LFMMarketResultMessage, None]: if cls.validate_json(json_message): return LFMMarketResultMessage(**json_message) return None LFMMarketResultMessage.register_to_factory()

f7482ac691a0fdfdc007363f5bd8272711320b3d

py

Python

autolrn/encoding/labelenc.py

SimonCarozza/autolrn

d0875844a3e9b4fc22510ef320aa498e339b6192

autolrn/encoding/labelenc.py

SimonCarozza/autolrn

d0875844a3e9b4fc22510ef320aa498e339b6192

autolrn/encoding/labelenc.py

SimonCarozza/autolrn

d0875844a3e9b4fc22510ef320aa498e339b6192

"""Label encode and One-Hot encode dataframes.""" from sklearn.preprocessing import LabelEncoder from pandas import get_dummies from pandas import DataFrame from pandas import Series from pandas import concat from pandas import merge import numpy as np # Auto encodes any dataframe column of type category or object. def dummy_encode(df): """ Encode any dataframe column of type category or object. --- df: pandas dataframe """ columnsToEncode = list( df.select_dtypes(include=['category', 'object'])) df1 = df.copy() for feature in columnsToEncode: le = LabelEncoder() try: df1[feature] = le.fit_transform(df[feature].astype(str)) except Exception as e: print(e) print('Error encoding ' + feature) return df1 ####### def le_encode_column(column): """Label-encode pandas DataFrame column or Series""" le = LabelEncoder() le_column = le.fit_transform(column.astype(str)) if isinstance(column, DataFrame): le_column = Series(le_column).to_frame(column.name) # equivalent to: # le_column = DataFrame(le_column, columns=[df_column.name]) elif isinstance(column, Series): le_column = Series(le_column) else: raise TypeError( "'column' should be of type pandas.DataFrame/Series") return le_column def encode_df_column(df_column): """Convert dataframe column 'df_column' into df w dummy variables.""" # print("column name: ", df_column.name) # if df_column.isin([' ']): # df_column = df_column.str.replace(' ', '_') try: enc_df_column = get_dummies( df_column, prefix=df_column.name, prefix_sep='_') except MemoryError as me: print(me) print("MemoryError! Column: " + df_column.name) print("Proceed to label-encoding") enc_df_column = le_encode_column(df_column) except KeyError as ke: print(ke) print("KeyError! Column: " + df_column.name) except ValueError as ve: print(ve) print("ValueError! Column: " + df_column.name) except Exception: print('Error encoding feature ' + df_column.name) # print("column head", enc_df_column.head(1)) assert (len(enc_df_column) == len(df_column)), \ "Ouch! Encoded column's different length than original's!" return enc_df_column def get_date_features(df, freqs=None): """ Get dates objects from dataframe. --- df: pandas Dataframe freqs: frequencies of datetime objects """ new_df = DataFrame() if freqs is None: freqs = ['Year', 'Month', 'Day', 'Week', 'hour', 'min'] else: for f in freqs: if f not in ('Year', 'Month', 'Day', 'Week', 'hour', 'min'): raise ValueError( "'%s' is not a valid value. Valid values are:" "['Year', 'Month', 'Day', 'hour', 'min']" % f) for feature in df.columns: if df[feature].dtype == 'datetime64[ns]': for f in freqs: try: if f == 'Year': new_df[f] = df[feature].dt.year elif f == 'Month': new_df[f] = df[feature].dt.month elif f == 'Day': new_df[f] = df[feature].dt.day elif f == 'Week': new_df[f] = df[feature].dt.week elif f == 'hour': new_df[f] = df[feature].dt.hour else: new_df[f] = df[feature].dt.minute except KeyError as ke: print(ke) print("KeyError! Column: " + feature) except ValueError as ve: print(ve) print("ValueError! Column: " + feature) except Exception as e: raise e else: new_df[feature] = df[feature] assert (len(new_df.index) == len(df.index)), \ "Ouch, encoded dataframe's different length than original's!" # remove 0-columns new_df = new_df.loc[:, (new_df != 0).any(axis=0)] return new_df def get_dummies_or_label_encode(df, target=None, dummy_cols=10, ohe_dates=False): """ Label or One-Hot encode columns. --- df: pandas Dataframe ohe_dates: enable one-hot encoding of eventual date features """ df.reset_index(drop=True, inplace=True) if target is None: new_df = DataFrame() cols = df.columns else: new_df = df[target].to_frame(name=target) cols = df.drop([target], axis=1).columns # print() # print("New df's columns:\n", cols) # print() original_length = len(df.index) columns_to_encode = list( df.select_dtypes(include=['category', 'object', 'int64'])) for feature in cols: col = df[feature] if df[feature].dtype in (np.int64, 'object'): col = col.astype('category') nr_uniques = len(col.unique()) # print("%s's nr_uniques:" % feature, nr_uniques) # if df[feature].dtype.name in column_types: if feature in columns_to_encode: try: if new_df.empty: # print("new_df is empty") if ohe_dates: if feature in ('Year', 'Month', 'Day', 'Week', 'hour', 'min'): new_df = encode_df_column(col) else: new_df = le_encode_column(col).to_frame(feature) else: if nr_uniques < dummy_cols: new_df = encode_df_column(col) else: new_df = le_encode_column(col) if isinstance(new_df, Series): new_df = new_df.to_frame(feature) # you forgot this else: # merge() more efficient than concat if ohe_dates: if feature in ('Year', 'Month', 'Day', 'Week', 'hour', 'min'): new_df = merge( new_df, encode_df_column(col), left_index=True, right_index=True) else: new_df = merge( new_df, le_encode_column(col).to_frame(feature), left_index=True, right_index=True) else: new_df = merge( new_df, encode_df_column(col) if len(col.unique()) < dummy_cols \ else le_encode_column(col).to_frame(feature), left_index=True, right_index=True) # new_df = concat([ # new_df, # encode_df_column(col) if len(col.unique()) < dummy_cols \ # else le_encode_column(col).to_frame(feature)], axis=1) except KeyError as ke: print(ke) print("KeyError! Column: " + feature) except ValueError as ve: print(ve) print("ValueError! Column: " + feature) except Exception as e: raise e else: if new_df.empty: # print("new_df is empty") new_df = col.to_frame(feature) else: # more efficient than concat new_df = merge( new_df, col.to_frame(feature), left_index=True, right_index=True) # new_df = concat( # [new_df, col.to_frame(feature)], axis=1) # print("New df's head:\n", new_df.head()) # print("New df's length:", len(new_df.index)) assert (len(new_df.index) == original_length), \ "Ouch, encoded dataframe's different length than original's!" print() print("New final df's head:\n", new_df.head(3)) print("New df's tail:\n", new_df.tail(3)) # print("New df's columns:", list(new_df.columns)) # print("New df's length:", len(new_df.index)) # print("Old df's length:", original_length) return new_df

f7483dc41d7e3e1457294dcbb499f8e642d0b5a9

py

Python

pybo/config.py

mikkokotila/pybo

ae921861e3e8c18856f19c59fc4c7da8f2126c1c

pybo/config.py

mikkokotila/pybo

ae921861e3e8c18856f19c59fc4c7da8f2126c1c

pybo/config.py

mikkokotila/pybo

ae921861e3e8c18856f19c59fc4c7da8f2126c1c

# coding: utf-8 """Configuration file to set up Pybo """ from pathlib import Path import yaml default_config = '''tokenizer: trie_files: - &part 'particles.txt' - &ancient ancient.txt - &except exceptions.txt - &uncomp uncompound_lexicon.txt - &tsikchen tsikchen.txt - &oral0 oral_corpus_0.txt - &oral1 oral_corpus_1.txt - &oral2 oral_corpus_2.txt - &oral3 oral_corpus_3.txt - &record recordings_4.txt - &mgd mgd.txt - &verb verbs.txt skrt_files: - &skrt ~ssanskrit.txt pos_files: - &tibdict ~pTibetan.DICT freq_files: - &freq_mgd ~fmgd.txt Profile: empty: [] pytib: [*ancient, *except, *uncomp, *tsikchen, *tibdict, *part] POS: [*ancient, *except, *uncomp, *tsikchen, *tibdict, *part] PP: [*part] GMD: [*ancient, *except, *uncomp, *tsikchen, *mgd, *verb, *tibdict, *skrt, *freq_mgd, *part] pipeline: basic: pre: pre_basic tok: spaces proc: spaces_fulltext frm: plaintext pybo_raw_content: pre: pre_basic tok: pybo pybo_profile: GMD proc: pybo_raw_content frm: plaintext pybo_raw_lines: pre: pre_basic_lines tok: pybo pybo_profile: GMD proc: pybo_raw_content frm: plaintext syls: pre: pre_basic tok: syls proc: spaces_fulltext frm: plaintext pybo_raw_types: pre: pre_basic tok: pybo pybo_profile: GMD proc: pybo_raw_types frm: types''' class Config: """Configuration class Attributes : filename: Complete filename of the configuration file config : Dictionary object containing all the configuration elements """ def __init__(self, filename): """Initialize the class Converting the configuration file into a Python dictionnary object which contains all the necesary parameters to set up Pybo properly. The text file has to respect the YAML writing rules. For more information: 'https://pyyaml.org/wiki/PyYAML' :param filename: Filename of the file with its extension """ self.filename = Path(filename).resolve() if self.filename.suffix != ".yaml": raise Exception("Unrecognised file extension. It only supports .yaml files") # if the file doesn't exist, write it with the default values if not self.filename.is_file(): with self.filename.open('w', encoding='utf-8-sig') as f: f.write(default_config) with self.filename.open('r', encoding='utf-8-sig') as g: self.config = yaml.load(g.read()) def get_tokenizer_profile(self, profile): """Get the profile configuration list Each profile has a list of files which can be collected by this function. :param profile: the profile name :return: the list of files of the selected profile """ return self.config["tokenizer"]["Profile"][profile] def get_pipeline_profile(self, profile): return self.config["pipeline"][profile] def add_pipeline_profile(self, profile): print('ok') args_list = ['pre', 'tok', 'proc', 'frm', # components 'pybo_profile', # pybo 'left', 'right', # concs 'filename'] # others key = list(profile.keys()) assert len(key) == 1 key = key[0] parts = profile[key] component_keys = list(parts.keys()) assert len(component_keys) >= 4 for c in component_keys: assert c in args_list self.config['pipeline'][key] = parts def reset_default(self): """Resets the configuration file to the default values""" with self.filename.open('w', encoding='utf-8-sig') as f: f.write(default_config) if __name__ == '__main__': config = Config("pybo.yaml") config.add_pipeline_profile({'test': {'pre': 'test', 'tok': 'test1', 'proc': 'test2', 'frm': 'test3'}}) config.reset_default() print(config.get_tokenizer_profile('POS'))

f7485fd066424ede4f563d0a793586ac6a5a6a02

py

Python

tests/aquisition/test_measure.py

jvdoorn/SpectrumAnalyzer

264afaa795bd7246da2967d49b176361c454746e

2020-12-29T18:02:04.000Z

2020-12-29T18:02:04.000Z

tests/aquisition/test_measure.py

jvdoorn/SpectrumAnalyzer

264afaa795bd7246da2967d49b176361c454746e

2021-02-07T16:01:48.000Z

2022-03-12T00:51:26.000Z

tests/aquisition/test_measure.py

jvdoorn/SpectrumAnalyzer

264afaa795bd7246da2967d49b176361c454746e

import unittest import numpy as np from specc.analysis.analyzer import CircuitTester from specc.aquisition.daq import DataAcquisitionInterface from specc.data.results import SignalResponse from tests.utils import ACCEPTABLE_ERROR, TEST_AMPLITUDE, TEST_DF, TEST_FREQUENCY, TEST_SAMPLES, TEST_SAMPLE_RATE class TestDAQSampleRate(unittest.TestCase): def test_sample_rate_limits(self): minimum_sample_rate = 10 maximum_sample_rate = 100 class DAQInterfaceMock(DataAcquisitionInterface): MINIMUM_SAMPLE_RATE = minimum_sample_rate MAXIMUM_SAMPLE_RATE = maximum_sample_rate self.assertRaises(AssertionError, lambda: DAQInterfaceMock(minimum_sample_rate - 1)) self.assertRaises(AssertionError, lambda: DAQInterfaceMock(maximum_sample_rate + 1)) def test_sample_rate_value(self): initalization_sample_rate = 10 updated_sample_rate = 20 daq = DataAcquisitionInterface(initalization_sample_rate) self.assertEqual(daq.sample_rate, initalization_sample_rate) daq.sample_rate = updated_sample_rate self.assertEqual(daq.sample_rate, updated_sample_rate) class TestDAQTimeArray(unittest.TestCase): def setUp(self) -> None: self.daq = DataAcquisitionInterface(TEST_SAMPLE_RATE) self.time_array = self.daq.calculate_time_array(TEST_SAMPLES) def test_time_array_dimensions(self): self.assertEqual(1, len(self.time_array.shape), "The time array is not a 1D-ndarray.") self.assertEqual((TEST_SAMPLES,), self.time_array.shape) def test_time_array_values(self): expected_end_time = TEST_SAMPLES / TEST_SAMPLE_RATE self.assertEqual(0, self.time_array[0], "Time array did not start at 0.") self.assertEqual(expected_end_time, self.time_array[-1], f"Time array did not end at {expected_end_time}.") class TestDAQAnalyzerRead(unittest.TestCase): def setUp(self): class DAQMock(DataAcquisitionInterface): MOCK_OUTPUT_PHASE = np.pi / 4 def read(self, channels: np.ndarray, samples: int) -> np.ndarray: end_time = samples / self.sample_rate time_array = np.linspace(0, end_time, samples) if len(channels) == 1: signal = TEST_AMPLITUDE * np.sin(2 * np.pi * TEST_FREQUENCY * time_array) elif len(channels) == 2: signal = np.asarray([ TEST_AMPLITUDE * np.sin(2 * np.pi * TEST_FREQUENCY * time_array), TEST_AMPLITUDE * np.sin(2 * np.pi * TEST_FREQUENCY * time_array + self.MOCK_OUTPUT_PHASE), ]) else: raise NotImplementedError return signal self.daq = DAQMock(TEST_SAMPLE_RATE) self.analyzer = CircuitTester(self.daq, 'empty', 'empty') def test_measuring_single(self): response = self.analyzer.measure_single(TEST_SAMPLES) self.assertTrue(isinstance(response, SignalResponse)) self.assertAlmostEqual(self.daq.MOCK_OUTPUT_PHASE, response.relative_phase(TEST_FREQUENCY), delta=ACCEPTABLE_ERROR) self.assertAlmostEqual(1, response.relative_intensity(TEST_FREQUENCY, TEST_DF), delta=ACCEPTABLE_ERROR) if __name__ == '__main__': unittest.main()

f7486473166589d1446909259e7709fb68e2a5df

py

Python

src/structure/process_pdb.py

igordub/enm-research-project

c5c52f2a6b415bd871800bcf725fda23cb3fd542

src/structure/process_pdb.py

igordub/enm-research-project

c5c52f2a6b415bd871800bcf725fda23cb3fd542

src/structure/process_pdb.py

igordub/enm-research-project

c5c52f2a6b415bd871800bcf725fda23cb3fd542

# -*- coding: utf-8 -*- import click import logging from pathlib import Path from dotenv import find_dotenv, load_dotenv import os import pandas as pd from biopandas.pdb import PandasPdb from copy import deepcopy import src.utilities as utils @click.command() @click.argument('input_dir', type=click.Path(exists=True)) @click.argument('output_dir', type=click.Path()) def main_commandline(input_dir, output_dir): """ Proccesses interim PDB structures (from pdb/interim/) and creates PDB structural forms for simulations (saved in pdb/processed/). """ logger = logging.getLogger(__name__) logger.info('making processed PDB forms from interim PDB structures') main(input_dir, output_dir) def main(input_dir, output_dir): """ Proccesses interim PDB structures (from pdb/interim/) and creates PDB structural forms for simulations (saved in pdb/processed/). """ config = utils.read_config() pdb_code = config['pdb']['id'] # Data import pdb_struct = load_structure(pdb_code, input_dir, file_extension="pdb") # Data processing # Delete residues 1 and 216 # pdb_struct.df['ATOM'] = pdb_struct.df['ATOM'][(pdb_struct.df['ATOM']['residue_number'] != 1) \ # & (pdb_struct.df['ATOM']['residue_number'] != 216)] # Create structural forms pdb_0 = create_form(pdb_struct, form_idx=0) pdb_1 = create_form(pdb_struct, form_idx=1) pdb_2 = create_form(pdb_struct, form_idx=2) # Save processed data save_structure(pdb_0, 0, output_dir) save_structure(pdb_1, 1, output_dir) save_structure(pdb_2, 2, output_dir) def load_structure(pdb_code, input_dir, file_extension="pdb"): """ Loads PDB file inot BioPandas object. """ pdb_filepath = os.path.join(input_dir, "{}.{}".format(pdb_code, file_extension)) return PandasPdb().read_pdb(pdb_filepath) def create_form(data, form_idx=0): """ Creates PDB structure forms. form_idx = 0 is apo; 1 - holo1; and 2 - holo2 Note: Only works for homodimers. """ # Make a deep copy of BioPandas object to make changes data_out = deepcopy(data) # If form_idx == 2 that's holo2 already if form_idx == 1: hetatm_record_len = data_out.df['HETATM'].shape[0] # Keep only one ligand data_out.df['HETATM'] = data_out.df['HETATM'][:int(hetatm_record_len/2)] elif form_idx == 0: # Delete all 'HETATM' records data_out.df['HETATM'] = pd.DataFrame(columns=data_out.df['HETATM'].columns) return data_out def save_structure(data, form_idx, output_dir): """ Save BioPandas object as a PDB record file. """ output_filename = "{}.pdb".format(form_idx) data.to_pdb(path=os.path.join(output_dir, output_filename), records=['ATOM', 'HETATM'], gz=False, append_newline=True) if __name__ == '__main__': log_fmt = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' logging.basicConfig(level=logging.INFO, format=log_fmt) # not used in this stub but often useful for finding various files project_dir = Path(__file__).resolve().parents[2] # find .env automagically by walking up directories until it's found, then # load up the .env entries as environment variables load_dotenv(find_dotenv()) main_commandline()

f748b1172f3e0ca2af960e6acfaccec75a395009

py

Python

src/compas_cem/elements/trail.py

dylau/compas_cem

643c7d60cb9d6a9999cb96d39c44175cc8662a25

2020-12-11T14:35:19.000Z

2022-03-31T03:12:30.000Z

src/compas_cem/elements/trail.py

dylau/compas_cem

643c7d60cb9d6a9999cb96d39c44175cc8662a25

2020-10-09T00:08:05.000Z

2021-11-18T00:24:20.000Z

src/compas_cem/elements/trail.py

dylau/compas_cem

643c7d60cb9d6a9999cb96d39c44175cc8662a25

2021-12-28T02:29:47.000Z

2022-03-15T14:04:23.000Z

from compas_cem.elements import Edge class TrailEdge(Edge): """ A trail edge. Notes ----- If a plane is defined, it will override the absolute length of the trail edge. However, the sign of the length (e.g. the combinatorial state) is preserved. TODO: addexplicit combinatorial state to the signature of the constructor. """ def __init__(self, u, v, length, plane=None): super(TrailEdge, self).__init__(u, v) # TODO # self.attributes = {"length": length, "state": state, type": "trail", "plane": plane} self.attributes = {"length": length, "type": "trail", "plane": plane} def __repr__(self): """ """ st = "{0}(length={1!r}, plane={2!r})" return st.format(self.__class__.__name__, self.attributes["length"], self.attributes["plane"]) # ============================================================================== # Main # ============================================================================== if __name__ == "__main__": pass

f748f56f4e1a24811310c06c94386e264b91bd57

py

Python

schemes/parse_scheme_table.py

gold2718/ccpp-framework

66f1a069b6b15748e08adbe940b8ceb9b39619ab

schemes/parse_scheme_table.py

gold2718/ccpp-framework

66f1a069b6b15748e08adbe940b8ceb9b39619ab

2019-01-25T21:50:33.000Z

2021-09-03T16:57:43.000Z

schemes/parse_scheme_table.py

gold2718/ccpp-framework

66f1a069b6b15748e08adbe940b8ceb9b39619ab

#!/usr/bin/env python # Usage: ./parse_scheme_table.py filename1 [filename2 filename3 ...] # Input: fortran filenames with doxygen-compliant and CCPP-compliant physics schemes; the argument tables should have the following format: # !! \section arg_table_schemename_run # !! | local_name | standard_name | long_name | units | rank | type | kind | intent | optional | # !! |----------------|-------------------------------------------------------|------------------------------------|---------|------|---------|-----------|--------|----------| # !! | im | horizontal_loop_extent | horizontal loop extent, start at 1 | index | 0 | integer | | in | F | # !! | ix | horizontal_dimension | horizontal dimension | index | 0 | integer | | in | F | # !! | ... | ... | | | | | | | | # !! # Notes on the input format: # - the "\section arg_table_SubroutineName" command denotes the start of the table; SubroutineName must match the name of the subroutine that the argument table describes # - each line of the table must begin with the doxygen-delimiter '!!' # - table headers are the first row; right now, the only ones parsed into XML (only ones required) are 'local var name' => id, 'longname' => name, units => units, rank => rank, type => type # - the second row must have the |---|-----| format # - after the last row of the table, there should be a blank doxygen line (only '!!') to denote the end of the table # Output: for each filename specified, this routine converts the argument tables for all subroutines (*_init, *_run, *_finalize) into an XML file suitable to be used with mkcap.py (which generates the fortran code for the scheme cap) # - the script generates a separate file for each module within the given files import argparse #needed for command line argument filenames from xml.etree import ElementTree as ET #needed for writing out XML #subroutine for writing "pretty" XML; copied from http://effbot.org/zone/element-lib.htm#prettyprint def indent(elem, level=0): i = "\n" + level*" " if len(elem): if not elem.text or not elem.text.strip(): elem.text = i + " " if not elem.tail or not elem.tail.strip(): elem.tail = i for elem in elem: indent(elem, level+1) if not elem.tail or not elem.tail.strip(): elem.tail = i else: if level and (not elem.tail or not elem.tail.strip()): elem.tail = i #set up the command line argument parser parser = argparse.ArgumentParser() #the only arguments are a list of filenames to parse parser.add_argument('file', help='paths to fortran source code to parse for generating CCPP scheme XML files', nargs='*') args = parser.parse_args() def parse_scheme_tables(files): xmlfiles = [] #for each filename provided, parse it and output one XML file for i in range(len(files)): filename = files[i] #read all lines of the file at once with (open(filename, 'r')) as file: file_lines = file.readlines() #find all modules within the file, and save the start and end lines module_names = [] mod_begin_lines = [] mod_end_lines = [] line_counter = 0 for line in file_lines: words = line.split() for j in range(len(words)): #check for the word 'module', that it is the first word in the line, and that a module name exists afterward if words[j].lower() == 'module' and j+1 <= len(words)-1 and j == 0: mod_begin_lines.append(line_counter) module_names.append(words[j+1].lower().strip()) if line.lower().find('end module') >= 0: mod_end_lines.append(line_counter) line_counter += 1 #for each module within the file, create a separate XML file for the "scheme" for l in range(len(module_names)): #find the *_init, *_run, *_finalize, etc. subroutines, save their location within the file and their names line_counter = 0 sub_lines = [] sub_names = [] scheme_names = [] #only look at the lines in the current module for line in file_lines[mod_begin_lines[l]:mod_end_lines[l]]: words = line.split() for j in range(len(words)): #check for the word 'subroutine', that it is the first word in the line, and that a subroutine name exists afterward if words[j].lower() == 'subroutine' and j+1 <= len(words)-1 and j == 0: #consider the last substring separated by a '_' of the subroutine name as a 'postfix' sub_name = words[j+1].split('(')[0].strip() if sub_name.find('_') >= 0: #ignore subroutines that have no postfix if sub_name.find('init') >= 0 or sub_name.find('run') >= 0 or sub_name.find('finalize') >= 0: #ignore subroutines that have postfixes other than init, run, finalize sub_lines.append(line_counter) #DH* case sensitive? sub_names.append(sub_name) sub_names.append(sub_name.lower()) scheme_names.append(sub_names[-1][0:sub_names[-1].rfind('_')]) line_counter += 1 #check that all the subroutine "root" names in the current module are the same if scheme_names.count(scheme_names[0]) == len(scheme_names): scheme_name = scheme_names[0] else: message = 'Please check that all of the subroutines have the same root name:\n' message += ' i.e. scheme_A_init, scheme_A_run, scheme_A_finalize\n' message += 'Here is a list of the subroutine names:\n' message += str(sub_names) + '\n' message += 'Here is a list of the scheme names (parsed from the subroutine names):\n' message += str(scheme_names) raise Exception(message) table_header_sets = [] var_data_sets = [] for j in range(len(sub_names)): #find the argument table corresponding to each subroutine by searching #"upward" from the subroutine definition line for the "arg_table_SubroutineName" section table_found = False for k in range(mod_begin_lines[l] + sub_lines[j], -1, -1): line = file_lines[k] words = line.split() for word in words: if 'arg_table_' + sub_names[j] in word.lower(): # DH* case sensitive? if 'arg_table_' + sub_names[j] in word: table_found = True header_line = k + 1 break if table_found: break #if an argument table is found, parse it if table_found: #separate the table headers table_headers = file_lines[header_line].split('|') #check for blank table if(len(table_headers) > 1): table_headers = table_headers[1:-1] table_header_sets.append([x.strip() for x in table_headers]) #get all of the variable information end_of_table = False k = header_line + 2 var_data = [] while not end_of_table: line = file_lines[k] words = line.split() if len(words) == 1: end_of_table = True else: var_items = line.split('|')[1:-1] var_items = [x.strip() for x in var_items] var_data.append(var_items) k += 1 var_data_sets.append(var_data) else: table_header_sets.append([]) var_data_sets.append([]) else: #if no table is found, just append an empty list table_header_sets.append([]) var_data_sets.append([]) #write out the XML in the format that mkcap.py wants top = ET.Element('scheme') top.set('module', scheme_name) for j in range(len(sub_names)): sub_sub = ET.SubElement(top, 'subroutine') sub_sub.set('name', sub_names[j]) #right now, the mapping from the tables to the XML is # 'local var name' => id, 'longname' => name, # units => units, rank => rank, type => type, # description => description, kind => kind, # intent => intent, optional => optional #this can be generalized and updated in the future using the table header information #### if len(var_data_sets[j]) > 0: for k in range(len(var_data_sets[j])): sub_var = ET.SubElement(sub_sub, 'var') var_name = ET.SubElement(sub_var, 'name') try: var_name.text = var_data_sets[j][k][1] except IndexError: raise IndexError('This can be caused by the argument table missing an empty (!!) line in {0}'.format(filename)) var_units = ET.SubElement(sub_var, 'units') var_units.text = var_data_sets[j][k][3] var_id = ET.SubElement(sub_var, 'id') var_id.text = var_data_sets[j][k][0] var_rank = ET.SubElement(sub_var, 'rank') var_rank.text = var_data_sets[j][k][4] var_type = ET.SubElement(sub_var, 'type') var_type.text = var_data_sets[j][k][5] var_description = ET.SubElement(sub_var, 'description') var_description.text = var_data_sets[j][k][2] var_kind = ET.SubElement(sub_var, 'kind') var_kind.text = var_data_sets[j][k][6] var_intent = ET.SubElement(sub_var, 'intent') var_intent.text = var_data_sets[j][k][7] var_optional = ET.SubElement(sub_var, 'optional') var_optional.text = var_data_sets[j][k][8] indent(top) tree = ET.ElementTree(top) xmlfile = scheme_name + '.xml' tree.write(xmlfile, xml_declaration=True, encoding='utf-8', method="xml") print 'Parsed tables for ' + ", ".join([str(x) for x in sub_names] ) + ' in module ' \ + module_names[l] + '; output => ' + xmlfile xmlfiles.append(xmlfile) return xmlfiles def main(): #set up the command line argument parser parser = argparse.ArgumentParser() #the only arguments are a list of filenames to parse parser.add_argument('file', help='paths to fortran source code to parse for generating CCPP scheme XML files', nargs='*') args = parser.parse_args() #parse scheme tables in all files parse_scheme_tables(args.file) if __name__ == '__main__': main()

f74907b936eb00941f148a9f06560e3d56a0302c

py

Python

products/models.py

benoitboyer/DjangoBio

415e048e7207f4abc6ac9b6bde7b7c7043aab78a

products/models.py

benoitboyer/DjangoBio

415e048e7207f4abc6ac9b6bde7b7c7043aab78a

products/models.py

benoitboyer/DjangoBio

415e048e7207f4abc6ac9b6bde7b7c7043aab78a

from django.db import models # Create your models here. class Product(models.Model): product_brand = models.CharField(max_length=50) product_article_code = models.CharField(max_length=20) product_code= models.IntegerField() product_name= models.CharField(max_length=150) product_unit_packaging_number = models.IntegerField(default=1) product_price = models.DecimalField(max_digits=8,decimal_places=2) product_selected = models.BooleanField(default=False) def __str__(self): return self.product_name def product_was_selected(self): return self.product_selected def get_price(self): return self.product_price def get_selected_product(): return Product.objects.filter(product_selected=True)

f74922ca39a253d92a9c87dae1b6068ed0dd843c

py

Python

eland/ml/_model_serializer.py

mesejo/eland

d1444f8e094ef11ce4fa6713a521245b68a842d7

eland/ml/_model_serializer.py

mesejo/eland

d1444f8e094ef11ce4fa6713a521245b68a842d7

eland/ml/_model_serializer.py

mesejo/eland

d1444f8e094ef11ce4fa6713a521245b68a842d7

# Licensed to Elasticsearch B.V under one or more agreements. # Elasticsearch B.V licenses this file to you under the Apache 2.0 License. # See the LICENSE file in the project root for more information import base64 import gzip import json from abc import ABC from typing import Sequence, Dict, Any, Optional def add_if_exists(d: Dict[str, Any], k: str, v: Any) -> None: if v is not None: d[k] = v class ModelSerializer(ABC): def __init__( self, feature_names: Sequence[str], target_type: Optional[str] = None, classification_labels: Optional[Sequence[str]] = None, ): self._target_type = target_type self._feature_names = feature_names self._classification_labels = classification_labels def to_dict(self) -> Dict[str, Any]: d: Dict[str, Any] = {} add_if_exists(d, "target_type", self._target_type) add_if_exists(d, "feature_names", self._feature_names) add_if_exists(d, "classification_labels", self._classification_labels) return d @property def feature_names(self) -> Sequence[str]: return self._feature_names def serialize_model(self) -> Dict[str, Any]: return {"trained_model": self.to_dict()} def serialize_and_compress_model(self) -> str: json_string = json.dumps(self.serialize_model(), separators=(",", ":")) return base64.b64encode(gzip.compress(json_string.encode("utf-8"))).decode( "ascii" ) class TreeNode: def __init__( self, node_idx: int, default_left: Optional[bool] = None, decision_type: Optional[str] = None, left_child: Optional[int] = None, right_child: Optional[int] = None, split_feature: Optional[int] = None, threshold: Optional[float] = None, leaf_value: Optional[float] = None, ): self._node_idx = node_idx self._decision_type = decision_type self._left_child = left_child self._right_child = right_child self._split_feature = split_feature self._threshold = threshold self._leaf_value = leaf_value self._default_left = default_left def to_dict(self) -> Dict[str, Any]: d: Dict[str, Any] = {} add_if_exists(d, "node_index", self._node_idx) add_if_exists(d, "decision_type", self._decision_type) if self._leaf_value is None: add_if_exists(d, "left_child", self._left_child) add_if_exists(d, "right_child", self._right_child) add_if_exists(d, "split_feature", self._split_feature) add_if_exists(d, "threshold", self._threshold) else: add_if_exists(d, "leaf_value", self._leaf_value) return d class Tree(ModelSerializer): def __init__( self, feature_names: Sequence[str], target_type: Optional[str] = None, tree_structure: Optional[Sequence[TreeNode]] = None, classification_labels: Optional[Sequence[str]] = None, ): super().__init__( feature_names=feature_names, target_type=target_type, classification_labels=classification_labels, ) if target_type == "regression" and classification_labels: raise ValueError("regression does not support classification_labels") self._tree_structure = tree_structure or [] def to_dict(self) -> Dict[str, Any]: d = super().to_dict() add_if_exists(d, "tree_structure", [t.to_dict() for t in self._tree_structure]) return {"tree": d} class Ensemble(ModelSerializer): def __init__( self, feature_names: Sequence[str], trained_models: Sequence[ModelSerializer], output_aggregator: Dict[str, Any], target_type: Optional[str] = None, classification_labels: Optional[Sequence[str]] = None, classification_weights: Optional[Sequence[float]] = None, ): super().__init__( feature_names=feature_names, target_type=target_type, classification_labels=classification_labels, ) self._trained_models = trained_models self._classification_weights = classification_weights self._output_aggregator = output_aggregator def to_dict(self) -> Dict[str, Any]: d = super().to_dict() trained_models = None if self._trained_models: trained_models = [t.to_dict() for t in self._trained_models] add_if_exists(d, "trained_models", trained_models) add_if_exists(d, "classification_weights", self._classification_weights) add_if_exists(d, "aggregate_output", self._output_aggregator) return {"ensemble": d}

f74940774759d64a85f79cb06fe04419f5dcf521

py

Python

autotest/gdrivers/netcdf_cf.py

chambbj/gdal

3d56aecb5b8e9890dae8f560acd099992e707d12

2015-02-16T16:51:38.000Z

2015-02-16T16:51:38.000Z

autotest/gdrivers/netcdf_cf.py

theduckylittle/gdal

61be261cae524582ba28bceebb027cc1e967e0ab

autotest/gdrivers/netcdf_cf.py

theduckylittle/gdal

61be261cae524582ba28bceebb027cc1e967e0ab

#!/usr/bin/env python ############################################################################### # $Id$ # # Project: GDAL/OGR Test Suite # Purpose: Test NetCDF driver support. # Author: Frank Warmerdam <warmerdam@pobox.com> # ############################################################################### # Copyright (c) 2007, Frank Warmerdam <warmerdam@pobox.com> # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. ############################################################################### import os import sys from osgeo import gdal from osgeo import osr from gdalconst import * sys.path.append( '../pymod' ) import gdaltest import imp # for netcdf_cf_setup() import netcdf from netcdf import netcdf_setup, netcdf_test_copy ############################################################################### # Netcdf CF compliance Functions ############################################################################### ############################################################################### #check for necessary files and software def netcdf_cf_setup(): #global vars gdaltest.netcdf_cf_method = None gdaltest.netcdf_cf_files = None gdaltest.netcdf_cf_check_error = '' #if netcdf is not supported, skip detection if gdaltest.netcdf_drv is None: return 'skip' #skip if on windows if os.name != 'posix': print('NOTICE: will skip CF checks because OS is not posix!') return 'skip' #try local method cdms2_installed = False try: imp.find_module( 'cdms2' ) cdms2_installed = True except ImportError: print( 'NOTICE: cdms2 not installed!' ) print( ' see installation notes at http://pypi.python.org/pypi/cfchecker' ) pass if cdms2_installed: xml_dir = './data/netcdf_cf_xml' tmp_dir = './tmp/cache' files = dict() files['a'] = xml_dir+'/area-type-table.xml' files['s'] = tmp_dir+'/cf-standard-name-table-v18.xml' #either find udunits path in UDUNITS_PATH, or based on location of udunits app, or copy all .xml files to data #opt_u = '/home/soft/share/udunits/udunits2.xml' files['u'] = xml_dir+'/udunits2.xml' #look for xml files if not ( os.path.exists(files['a']) and os.path.exists(files['s']) and os.path.exists(files['u']) ): print('NOTICE: cdms2 installed, but necessary xml files are not found!') print(' the following files must exist:') print(' '+xml_dir+'/area-type-table.xml from http://cf-pcmdi.llnl.gov/documents/cf-standard-names/area-type-table/1/area-type-table.xml') print(' '+tmp_dir+'/cf-standard-name-table-v18.xml - http://cf-pcmdi.llnl.gov/documents/cf-standard-names/standard-name-table/18/cf-standard-name-table.xml') print(' '+xml_dir+'/udunits2*.xml from a UDUNITS2 install') #try to get cf-standard-name-table if not os.path.exists(files['s']): #print ' downloading cf-standard-name-table.xml (v18) from http://cf-pcmdi.llnl.gov ...' if not gdaltest.download_file('http://cf-pcmdi.llnl.gov/documents/cf-standard-names/standard-name-table/18/cf-standard-name-table.xml', 'cf-standard-name-table-v18.xml'): print(' Failed to download, please get it and try again.') if os.path.exists(files['a']) and os.path.exists(files['s']) and os.path.exists(files['u']): gdaltest.netcdf_cf_method = 'local' gdaltest.netcdf_cf_files = files print('NOTICE: netcdf CF compliance checks: using local checker script') return 'success' #skip http method if GDAL_DOWNLOAD_TEST_DATA and GDAL_RUN_SLOW_TESTS are not defined if not 'GDAL_DOWNLOAD_TEST_DATA' in os.environ: print('NOTICE: skipping netcdf CF compliance checks') print('to enable remote http checker script, define GDAL_DOWNLOAD_TEST_DATA') return 'success' if not gdaltest.run_slow_tests(): print('NOTICE: skipping netcdf CF compliance checks') return 'success' #http method with curl, should use python module but easier for now success = False try: (ret, err) = gdaltest.runexternal_out_and_err('curl') except : print('no curl executable') else: #make sure script is responding handle = gdaltest.gdalurlopen("http://puma.nerc.ac.uk/cgi-bin/cf-checker.pl") if handle is not None: success = True else: print('script not responding') if success: gdaltest.netcdf_cf_method = 'http' print('NOTICE: netcdf CF compliance ckecks: using remote http checker script, consider installing cdms2 locally') return 'success' if gdaltest.netcdf_cf_method is None: print('NOTICE: skipping netcdf CF compliance checks') return 'success' ############################################################################### #build a command used to check ifile def netcdf_cf_get_command(ifile, version='auto'): command = '' #fetch method obtained previously method = gdaltest.netcdf_cf_method if method is not None: if method is 'local': command = './netcdf_cfchecks.py -a ' + gdaltest.netcdf_cf_files['a'] \ + ' -s ' + gdaltest.netcdf_cf_files['s'] \ + ' -u ' + gdaltest.netcdf_cf_files['u'] \ + ' -v ' + version +' ' + ifile elif method is 'http': #command = shlex.split( 'curl --form cfversion="1.5" --form upload=@' + ifile + ' --form submit=\"Check file\" "http://puma.nerc.ac.uk/cgi-bin/cf-checker.pl"' ) #switch to 1.5 as driver now supports, and auto when it becomes available version = '1.5' command = 'curl --form cfversion=' + version + ' --form upload=@' + ifile + ' --form submit=\"Check file\" "http://puma.nerc.ac.uk/cgi-bin/cf-checker.pl"' return command ############################################################################### # Check a file for CF compliance def netcdf_cf_check_file(ifile,version='auto', silent=True): #if not silent: # print 'checking file ' + ifile gdaltest.netcdf_cf_check_error = '' if ( not os.path.exists(ifile) ): return 'skip' output_all = '' command = netcdf_cf_get_command(ifile, version='auto') if command is None or command=='': gdaltest.post_reason('no suitable method found, skipping') return 'skip' try: if gdaltest.netcdf_cf_method == 'http': print('calling ' + command) (ret, err) = gdaltest.runexternal_out_and_err(command) except : gdaltest.post_reason('ERROR with command - ' + command) return 'fail' output_all = ret output_err = '' output_warn = '' for line in output_all.splitlines( ): #optimize this with regex if 'ERROR' in line and not 'ERRORS' in line: output_err = output_err + '\n' + line elif 'WARNING' in line and not 'WARNINGS' in line: output_warn = output_warn + '\n' + line result = 'success' if output_err != '': result = 'fail' if output_err != '': gdaltest.netcdf_cf_check_error += output_err.strip() if not silent: print('=> CF check ERRORS for file ' + ifile + ' : ' + output_err) if output_warn != '': if not silent: print('CF check WARNINGS for file ' + ifile + ' : ' + output_warn) return result ############################################################################### # Netcdf CF projection Functions and data ############################################################################### ############################################################################### # Definitions to test projections that are supported by CF # Tuple structure: # 0: Short code (eg AEA) - (no GDAL significance, just for filenames etc) # 1: official name from CF-1 conventions # 2: EPSG code, or WKT, to tell GDAL to do reprojection # 3: Actual attribute official name of grid mapping # 4: List of required attributes to define projection # 5: List of required coordinate variable standard name attributes netcdf_cfproj_tuples = [ ("AEA", "Albers Equal Area", "EPSG:3577", "albers_conical_equal_area", ['standard_parallel', 'longitude_of_central_meridian', 'latitude_of_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']), ("AZE", "Azimuthal Equidistant", #Didn't have EPSG suitable for AU "+proj=aeqd +lat_0=-37 +lon_0=145 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", "azimuthal_equidistant", ['longitude_of_projection_origin', 'latitude_of_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']), ("LAZEA", "Lambert azimuthal equal area", #Specify proj4 since no approp LAZEA for AU #"+proj=laea +lat_0=0 +lon_0=134 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs", "+proj=laea +lat_0=-37 +lon_0=145 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", "lambert_azimuthal_equal_area", ['longitude_of_projection_origin', 'latitude_of_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']), ("LC_2SP", "Lambert conformal", "EPSG:3112", "lambert_conformal_conic", ['standard_parallel', 'longitude_of_central_meridian', 'latitude_of_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']), # TODO: Test LCC with 1SP ("LCEA", "Lambert Cylindrical Equal Area", "+proj=cea +lat_ts=-37 +lon_0=145 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", "lambert_cylindrical_equal_area", ['longitude_of_central_meridian', 'standard_parallel', # TODO: OR 'scale_factor_at_projection_origin' 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']), # 2 entries for Mercator, since attribs different for 1SP or 2SP ("M-1SP", "Mercator", "+proj=merc +lon_0=145 +k_0=1 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", "mercator", ['longitude_of_projection_origin', 'scale_factor_at_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']), # Commented out as it seems GDAL itself's support of Mercator with 2SP # is a bit dodgy ("M-2SP", "Mercator", "+proj=merc +lat_ts=-37 +lon_0=145 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", # Trying with full WKT: #"""PROJCS["unnamed", GEOGCS["WGS 84", DATUM["WGS_1984", SPHEROID["WGS 84",6378137,298.257223563, AUTHORITY["EPSG","7030"]], AUTHORITY["EPSG","6326"]], PRIMEM["Greenwich",0], UNIT["degree",0.0174532925199433], AUTHORITY["EPSG","4326"]], PROJECTION["Mercator_2SP"], PARAMETER["central_meridian",146], PARAMETER["standard_parallel_1",-37], PARAMETER["latitude_of_origin",0], PARAMETER["false_easting",0], PARAMETER["false_northing",0], UNIT["metre",1, AUTHORITY["EPSG","9001"]]]""", "mercator", ['longitude_of_projection_origin', 'standard_parallel', 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']), ("Ortho", "Orthographic", "+proj=ortho +lat_0=-37 +lon_0=145 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", "orthographic", ['longitude_of_projection_origin', 'latitude_of_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate', 'projection_y_coordinate']), # Seems GDAL may have problems with Polar stereographic, as it # considers these "local coordinate systems" ("PSt", "Polar stereographic", "+proj=stere +lat_ts=-37 +lat_0=-90 +lon_0=145 +k_0=1.0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", "polar_stereographic", ['straight_vertical_longitude_from_pole', 'latitude_of_projection_origin', 'standard_parallel', 'false_easting', 'false_northing'], ['projection_x_coordinate', 'projection_y_coordinate']), ("St", "Stereographic", "+proj=stere +lat_0=-37 +lon_0=145 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs", #'PROJCS["unnamed", GEOGCS["WGS 84", DATUM["WGS_1984", SPHEROID["WGS 84",6378137,298.257223563, AUTHORITY["EPSG","7030"]], AUTHORITY["EPSG","6326"]], PRIMEM["Greenwich",0], UNIT["degree",0.0174532925199433], AUTHORITY["EPSG","4326"]], PROJECTION["Stereographic"], PARAMETER["latitude_of_origin",-37.5], PARAMETER["central_meridian",145], PARAMETER["scale_factor",1], PARAMETER["false_easting",0], PARAMETER["false_northing",0], UNIT["metre",1, AUTHORITY["EPSG","9001"]]]', "stereographic", ['longitude_of_projection_origin', 'latitude_of_projection_origin', 'scale_factor_at_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate', 'projection_y_coordinate']), #Note: Rotated Pole not in this list, as seems not GDAL-supported ("TM", "Transverse Mercator", "EPSG:32655", #UTM Zone 55N "transverse_mercator", [ 'scale_factor_at_central_meridian', 'longitude_of_central_meridian', 'latitude_of_projection_origin', 'false_easting', 'false_northing'], ['projection_x_coordinate','projection_y_coordinate']) ] #By default, we will use GeoTiff as the 'intermediate' raster format # for gdalwarp'ing into before gdal_translate to NetCDF. # But since GeoTiff can't act as a storage format for certain projections # (eg Mercator-2SP), we will choose other intermediate formats for certain # projection. # The following array maps projection short code, to driver format to use netcdf_cfproj_def_int_format = "GTiff" netcdf_cfproj_int_fmt_maps = { "M-2SP":'HFA' } netcdf_cfproj_format_fnames = {"HFA":"img", "GTiff":"tif", "NITF":"nitf", "ERS":"ers"} ############################################################################### # Check support for given projection tuple definitions # For each projection, warp the original file and then create a netcdf def netcdf_cfproj_testcopy(projTuples, origTiff, interFormats, inPath, outPath, resFilename): """Test a Geotiff file can be converted to NetCDF, and projection in CF-1 conventions can be successfully maintained. Save results to file. :arg: projTuples - list of tuples :arg: interFormats - dict of intermediate format overrides :arg: outPath - path to save output :arg: resFilename - results filename to write to. """ silent = True gdaltest.netcdf_drv_silent = True bWriteGdalTags="YES" #silent = False gdaltest.netcdf_drv_silent = False # bWriteGdalTags="NO" result = 'success' # Test if ncdump is available try: (ret, err) = gdaltest.runexternal_out_and_err('ncdump -h') except: #nothing is supported as ncdump not found print('NOTICE: netcdf version not found') return 'skip' i = err.find('netcdf library version ') #version not found if i == -1: print('NOTICE: netcdf version not found') return 'skip' if not os.path.exists(outPath): os.makedirs(outPath) resFile = open(os.path.join(outPath, resFilename), "w") if not os.path.exists(outPath): os.makedirs(outPath) heading = "Testing GDAL translation results to NetCDF\n" resFile.write(heading) resFile.write(len(heading)*"="+"\n") # now = datetime.datetime.now() # resFile.write("*Date/time:* %s\n" % (now.strftime("%Y-%m-%d %H:%M"))) resFile.write("\n") resPerProj = {} dsTiff = gdal.Open( os.path.join(inPath, origTiff), GA_ReadOnly ); s_srs_wkt = dsTiff.GetProjection() #objects to hold the various tests i_t = 0 tst = {} tst_res = {} for proj in projTuples: try: intFmt = interFormats[proj[0]] except KeyError: intFmt = netcdf_cfproj_def_int_format intExt = netcdf_cfproj_format_fnames[intFmt] # Our little results data structures if not silent: print("") print("Testing %s (%s) translation:" % (proj[0], proj[1])) if not silent: print("About to create raster in chosen SRS") projVrt = os.path.join(outPath, "%s_%s.vrt" % \ (origTiff.rstrip('.tif'), proj[0] )) projRaster = os.path.join(outPath, "%s_%s.%s" % \ (origTiff.rstrip('.tif'), proj[0], intExt )) srs = osr.SpatialReference() srs.SetFromUserInput(proj[2]) t_srs_wkt = srs.ExportToWkt() if not silent: print("going to warp file "+origTiff+"\n" + s_srs_wkt + "\ninto file "+projRaster + "\n" + t_srs_wkt) dswarp = gdal.AutoCreateWarpedVRT( dsTiff, s_srs_wkt, t_srs_wkt, GRA_NearestNeighbour, 0 ); drv_inter = gdal.GetDriverByName(intFmt); drv_netcdf = gdal.GetDriverByName("netcdf"); dsw = drv_inter.CreateCopy(projRaster, dswarp, 0) if not silent: print("Warped %s to %s" % (proj[0], projRaster)) projNc = os.path.join(outPath, "%s_%s.nc" % \ (origTiff.rstrip('.tif'), proj[0] )) #Force GDAL tags to be written to make testing easier, with preserved datum etc ncCoOpts = "-co WRITE_GDAL_TAGS=yes" if not silent: print("About to translate to NetCDF") dst = drv_netcdf.CreateCopy(projNc, dsw, 0, [ 'WRITE_GDAL_TAGS='+bWriteGdalTags ]) #For drivers like HFA, line below ESSENTIAL so that all info is # saved to new raster file - which we'll reopen later and want # to be fully updated. dsw = None dst = None if not silent: print("Translated to %s" % (projNc)) transWorked, resDetails = netcdf_cfproj_test_cf(proj, projNc) resPerProj[proj[0]] = resDetails resFile.write("%s (%s): " % (proj[0], proj[1])) if transWorked: resFile.write("OK\n") else: resFile.write("BAD\n") if 'missingProjName' in resPerProj[proj[0]]: resFile.write("\tMissing proj name '%s'\n" % \ (resPerProj[proj[0]]['missingProjName'])) for attrib in resPerProj[proj[0]]['missingAttrs']: resFile.write("\tMissing attrib '%s'\n" % (attrib)) for cVarStdName in resPerProj[proj[0]]['missingCoordVarStdNames']: resFile.write("\tMissing coord var with std name '%s'\n" \ % (cVarStdName)) if 'cfcheck_error' in resPerProj[proj[0]]: resFile.write("\tFailed cf check: %s\n" % \ (resPerProj[proj[0]]['cfcheck_error'])) # test file copy # We now copy to a new file, just to be safe projNc2 = projNc.rstrip('.nc') + '2.nc' projRaster2 = os.path.join(outPath, "%s_%s2.%s" % \ (origTiff.rstrip('.tif'), proj[0], intExt )) tst_res[i_t+1] = netcdf_test_copy( projRaster, 1, None, projNc2, [], 'NETCDF' ) tst_res[i_t+2] = netcdf_test_copy( projNc2, 1, None, projRaster2, [], intFmt ) if tst_res[i_t+1] == 'fail' or tst_res[i_t+2] == 'fail': result = 'fail' i_t = i_t + 2 resFile.close() if not silent: print("\n" + "*" * 80) print("Saved results to file %s" % (os.path.join(outPath, resFilename))) #result = 'success' resFile = open(os.path.join(outPath, resFilename), "r") resStr = resFile.read() if resStr.find('BAD') != -1: print('\nCF projection tests failed, here is the output (stored in file %s)\n' % \ (os.path.join(outPath, resFilename))) print(resStr) result = 'fail' return result ############################################################################### # Test an NC file has valid conventions according to passed-in proj tuple # Note: current testing strategy is a fairly simple attribute search. # this could use gdal netcdf driver for getting attribs instead... def netcdf_cfproj_test_cf(proj, projNc): transWorked = True command = 'ncdump -h ' + projNc (ret, err) = gdaltest.runexternal_out_and_err(command) if err != '': print(err) dumpStr = ret resDetails = {} resDetails['missingAttrs'] = [] resDetails['missingCoordVarStdNames'] = [] if (':grid_mapping_name = "%s"' % (proj[3])) not in dumpStr: transWorked = False resDetails['missingProjName'] = proj[3] # Check attributes in the projection are included for attrib in proj[4]: # The ':' prefix and ' ' suffix is to help check for exact name, # eg to catch the standard_parallel_1 and 2 issue. if (":"+attrib+" ") not in dumpStr: transWorked = False resDetails['missingAttrs'].append(attrib) # print "**Error for proj '%s': CF-1 attrib '%s' not found.**" % \ # (proj[0], attrib) # Now we check the required X and Y attributes are included (e.g. Rotated Pole # has special names required here. for coordVarStdName in proj[5]: if coordVarStdName not in dumpStr: transWorked = False resDetails['missingCoordVarStdNames'].append(coordVarStdName) #Final check use the cf-checker result_cf = netcdf_cf_check_file( projNc,'auto',True ) if result_cf == 'fail': resDetails['cfcheck_error'] = gdaltest.netcdf_cf_check_error transWorked = False return transWorked, resDetails ############################################################################### # Netcdf CF Tests ############################################################################### ############################################################################### #test copy and CF compliance for lat/lon (no datum, no GEOGCS) file, tif->nc->tif def netcdf_cf_1(): #setup netcdf and netcdf_cf environment netcdf_setup() netcdf_cf_setup() if gdaltest.netcdf_drv is None: return 'skip' #tst1 = gdaltest.GDALTest( 'NETCDF', 'trmm.tif', 1, 14 ) #result = tst1.testCreateCopy(check_gt=1, check_srs=1, new_filename='tmp/netcdf_cf_1.nc', delete_copy = 0) result = netcdf_test_copy( 'data/trmm.nc', 1, 14, 'tmp/netcdf_cf_1.nc' ) if result != 'fail': #tst2 = gdaltest.GDALTest( 'GTIFF', '../tmp/netcdf_cf_1.nc', 1, 14 ) #result = tst2.testCreateCopy(check_gt=1, check_srs=1, new_filename='tmp/netcdf_cf_1.tiff', delete_copy = 0) result = netcdf_test_copy( 'tmp/netcdf_cf_1.nc', 1, 14, 'tmp/netcdf_cf_1.tif', [], 'GTIFF' ) result_cf = 'success' if gdaltest.netcdf_cf_method is not None: result_cf = netcdf_cf_check_file( 'tmp/netcdf_18.nc','auto',False ) if result != 'fail' and result_cf != 'fail': return 'success' else: return 'fail' ############################################################################### #test copy and CF compliance for lat/lon (no datum, no GEOGCS) file, nc->nc def netcdf_cf_2(): if gdaltest.netcdf_drv is None: return 'skip' result = netcdf_test_copy( 'data/trmm.nc', 1, 14, 'tmp/netcdf_cf_2.nc' ) result_cf = 'success' if gdaltest.netcdf_cf_method is not None: result_cf = netcdf_cf_check_file( 'tmp/netcdf_cf_2.nc','auto',False ) if result != 'fail' and result_cf != 'fail': return 'success' else: return 'fail' ############################################################################### #test copy and CF compliance for lat/lon (W*S84) file, tif->nc->tif # note: this test fails in trunk (before r23246) def netcdf_cf_3(): if gdaltest.netcdf_drv is None: return 'skip' result = 'success' result_cf = 'success' result = netcdf_test_copy( 'data/trmm-wgs84.tif', 1, 14, 'tmp/netcdf_cf_3.nc' ) if result == 'success': #tst = gdaltest.GDALTest( 'GTIFF', '../tmp/netcdf_cf_3.nc', 1, 14 ) #result = tst.testCreateCopy(check_gt=1, check_srs=1, new_filename='tmp/netcdf_cf_3.tif', delete_copy = 0) result = netcdf_test_copy( 'tmp/netcdf_cf_3.nc', 1, 14, 'tmp/netcdf_cf_3.tif', [], 'GTIFF' ) result_cf = 'success' if gdaltest.netcdf_cf_method is not None: result_cf = netcdf_cf_check_file( 'tmp/netcdf_cf_3.nc','auto',False ) if result != 'fail' and result_cf != 'fail': return 'success' else: return 'fail' ############################################################################### #test support for various CF projections def netcdf_cf_4(): result = netcdf_cfproj_testcopy(netcdf_cfproj_tuples, 'melb-small.tif', netcdf_cfproj_int_fmt_maps, 'data', 'tmp', 'translate_results.txt') # result = netcdf_cfproj_testcopy(netcdf_cfproj_tuples1, 'melb-small.tif', \ # 'data', 'tmp', 'translate_results.txt') return result ############################################################################### #test support for PS variants (bug #2893) def netcdf_cf_5(): if gdaltest.netcdf_drv is None: return 'skip' ifiles = [ 'NETCDF:data/orog_CRCM1.nc:orog', 'NETCDF:data/orog_CRCM2.nc:orog' ] for ifile in ifiles: ds = gdal.Open( ifile ) prj = ds.GetProjection() sr = osr.SpatialReference( ) sr.ImportFromWkt( prj ) lat_origin = sr.GetProjParm( 'latitude_of_origin' ) if lat_origin != 60: gdaltest.post_reason( 'Latitude of origin in %s does not match expected: %f' % (ifile, lat_origin) ) return 'fail' return 'success' ############################################################################### gdaltest_list = [ netcdf_cf_1, netcdf_cf_2, netcdf_cf_3, netcdf_cf_4, netcdf_cf_5, None ] if __name__ == '__main__': gdaltest.setup_run( 'netcdf_cf' ) gdaltest.run_tests( gdaltest_list ) #make sure we cleanup gdaltest.clean_tmp() gdaltest.summarize()

f74959f1794d63d86a99d0bbf4f7c523d22281a1

py

Python

v3io_gputils/mpijob.py

sahare92/v3io-gputils

8d18c6b5b8d9051967295b75836708ffa645df81

v3io_gputils/mpijob.py

sahare92/v3io-gputils

8d18c6b5b8d9051967295b75836708ffa645df81

v3io_gputils/mpijob.py

sahare92/v3io-gputils

8d18c6b5b8d9051967295b75836708ffa645df81

from copy import deepcopy from os import environ from pprint import pprint import yaml from kubernetes import client, config from kubernetes.client.rest import ApiException _mpijob_template = { 'apiVersion': 'kubeflow.org/v1alpha1', 'kind': 'MPIJob', 'metadata': { 'name': '', 'namespace': 'default-tenant' }, 'spec': { 'replicas': 1, 'template': { 'spec': { 'containers': [{ 'image': 'iguaziodocker/horovod:0.1.1', 'name': '', 'command': [], 'volumeMounts': [{'name': 'v3io', 'mountPath': '/User'}], 'workingDir': '/User', 'securityContext': { 'capabilities': {'add': ['IPC_LOCK']}}, 'resources': { 'limits': {'nvidia.com/gpu': 1}}}], 'volumes': [{ 'name': 'v3io', 'flexVolume': { 'driver': 'v3io/fuse', 'options': { 'container': 'users', 'subPath': '', 'accessKey': '', } }}] }}}} class MpiJob: """ A wrapper over Kubernetes MPIJob (Horovod). Example: from mpijob import MpiJob job = MpiJob('myname', 'img', ['a','b']) print(job.to_yaml()) job.submit() """ group = 'kubeflow.org' version = 'v1alpha1' plural = 'mpijobs' def __init__(self, name, image=None, command=None, replicas=1, namespace='default-tenant'): self.api_instance = None self.name = name self.namespace = namespace self._struct = deepcopy(_mpijob_template) self._struct['metadata'] = {'name': name, 'namespace': namespace} self._update_container('name', name) if image: self._update_container('image', image) if command: self._update_container('command', ['mpirun','python'] + command) if replicas: self._struct['spec']['replicas'] = replicas self._update_access_token(environ.get('V3IO_ACCESS_KEY','')) self._update_running_user(environ.get('V3IO_USERNAME','')) def _update_container(self, key, value): self._struct['spec']['template']['spec']['containers'][0][key] = value def _update_access_token(self, token): self._struct['spec']['template']['spec']['volumes'][0]['flexVolume']['options']['accessKey'] = token def _update_running_user(self, username): self._struct['spec']['template']['spec']['volumes'][0]['flexVolume']['options']['subPath'] = '/' + username def volume(self, mount='/User', volpath='~/', access_key=''): self._update_container('volumeMounts', [{'name': 'v3io', 'mountPath': mount}]) if volpath.startswith('~/'): v3io_home = environ.get('V3IO_HOME', '') volpath = v3io_home + volpath[1:] container, subpath = split_path(volpath) access_key = access_key or environ.get('V3IO_ACCESS_KEY','') vol = {'name': 'v3io', 'flexVolume': { 'driver': 'v3io/fuse', 'options': { 'container': container, 'subPath': subpath, 'accessKey': access_key, } }} self._struct['spec']['template']['spec']['volumes'] = [vol] return self def gpus(self, num, gpu_type='nvidia.com/gpu'): self._update_container('resources', {'limits' : {gpu_type: num}}) return self def replicas(self, replicas_num): self._struct['spec']['replicas'] = replicas_num return self def working_dir(self, working_dir): self._update_container('workingDir', working_dir) return self def to_dict(self): return self._struct def to_yaml(self): return yaml.dump(self.to_dict(), default_flow_style=False, sort_keys=False) def submit(self): config.load_incluster_config() self.api_instance = client.CustomObjectsApi() try: api_response = self.api_instance.create_namespaced_custom_object( MpiJob.group, MpiJob.version, self.namespace, 'mpijobs', self.to_dict()) pprint(api_response) except ApiException as e: print("Exception when creating MPIJob: %s" % e) def delete(self): try: # delete the mpi job body = client.V1DeleteOptions() api_response = self.api_instance.delete_namespaced_custom_object( MpiJob.group, MpiJob.version, self.namespace, MpiJob.plural, self.name, body) pprint(api_response) except ApiException as e: print("Exception when calling CustomObjectsApi->delete_namespaced_custom_object: %s\\n" % e) def split_path(mntpath=''): if mntpath[0] == '/': mntpath = mntpath[1:] paths = mntpath.split('/') container = paths[0] subpath = '' if len(paths) > 1: subpath = mntpath[len(container):] return container, subpath

f7497600d642a7db6b364f43f0e0a50efd519232

py

Python

appengine/components/tools/log_since.py

stefb965/luci-py

e0a8a5640c4104e5c90781d833168aa8a8d1f24d