Datasets:

xlangai

/

the-stack-vault

like 0

f72a1840be2b7b6a8d90b8ea7f88260d3394c345

py

Python

api/ver1/offices/strings.py

pcf26536/politico-api

1c9b8755ddad2baf0bfdeab4aa0674e4197a0d7c

2019-02-22T19:34:32.000Z

2019-02-22T19:34:32.000Z

api/ver1/offices/strings.py

pcf26536/politico-api

1c9b8755ddad2baf0bfdeab4aa0674e4197a0d7c

api/ver1/offices/strings.py

pcf26536/politico-api

1c9b8755ddad2baf0bfdeab4aa0674e4197a0d7c

2019-02-07T22:12:25.000Z

2019-02-07T22:12:25.000Z

""" string constants for office module """ fed_type = 'federal' leg_type = 'legislative' state_type = 'state' loc_gov_type = 'local government' office_type_list = [fed_type, leg_type, state_type, loc_gov_type] office_id_str = 'Office ID ' office_key = 'office' prezzo = 'President' mca = 'Member of County Assembly' wr = 'Women Representative' gov = 'Governer' sen = 'Senator'

f72a5a03842d93e765331b1fe8130fe4969fd3ea

py

Python

temperature.py

balena-io-playground/balena-edison-monitoring-artik

d02ba51cda8edcbc0decc80d0dab7f724dc46014

2020-04-25T08:46:41.000Z

2021-02-11T17:36:27.000Z

temperature.py

balena-io-playground/balena-edison-monitoring-artik

d02ba51cda8edcbc0decc80d0dab7f724dc46014

temperature.py

balena-io-playground/balena-edison-monitoring-artik

d02ba51cda8edcbc0decc80d0dab7f724dc46014

""" Temperature monitoring with Intel Edison and Samsung ARTIK Cloud """ import sys import os import time from math import log import statistics from collections import deque import artikcloud from artikcloud.rest import ApiException import pyupm_grove as grove import mraa import requests # Setting credentials from the environmental variables DEVICE_ID = os.getenv('ARTIKCLOUD_DEVICE_ID') DEVICE_TOKEN = os.getenv('ARTIKCLOUD_DEVICE_TOKEN') try: AVERAGE = int(os.getenv('AVERAGE', 5)) except: AVERAGE = 5 finally: print("INFO: averaging over {} readings".format(AVERAGE)) PERIOD = 1 # Setting up ARTIK Cloud connection artikcloud.configuration.access_token = DEVICE_TOKEN # Setting up messaging messages_api = artikcloud.MessagesApi() # Create the temperature sensor object using AIO pin 0 temp = grove.GroveTemp(0) print(temp.name()) led = mraa.Gpio(4) led.dir(mraa.DIR_OUT) def reboot_device(): """Restart application through the resin Supervisor """ params = {'apikey': os.getenv('RESIN_SUPERVISOR_API_KEY')} payload = {'appId': os.getenv('RESIN_APP_ID')} supervisor_address = os.getenv('RESIN_SUPERVISOR_ADDRESS') print("Restarting Application") r = requests.post("{}/v1/reboot".format(supervisor_address), supervisor_address, params=params, json=payload) if r.status_code == 200: sys.exit(0) def temp_convert(sensor): """Adapted from UPM source code https://github.com/intel-iot-devkit/upm/blob/4faa71d239f3549556a61df1a9c6f81c3d06bda2/src/grove/grovetemp.cxx#L54-L63 """ a = sensor.raw_value() if a < 0: return -300 m_scale, m_r0, m_b = 1.0, 100000.0, 4275.0 # Apply scale factor after error check a *= m_scale r = (1023.0-a)*m_r0/a t = 1.0/(log(r/m_r0)/m_b + 1.0/298.15)-273.15 return t # Throw away readings to settle down print("Throw-away readings to settle") for i in range(5): celsius = temp_convert(temp) print("Current temperature: {0:.2f}".format(celsius)) time.sleep(1) print("Starting proper readings") i = 0 error_count = 0 readings = deque(maxlen=AVERAGE) while True: loopstart = time.time() celsius = temp_convert(temp) readings.append(celsius) meancelsius = statistics.mean(readings) print("Current temperature: {0:.2f} (mean: {1:.2f})".format(celsius, meancelsius)) if i % 600 == 0: # Send a new message message = artikcloud.Message() message.type = "message" message.sdid = "{}".format(DEVICE_ID) message.ts = int(round(time.time() * 1000)) # timestamp, required message.data = {'Temperature': meancelsius} try: response = messages_api.send_message(message) print(response) except ApiException as error: print("API ERROR: {}".format(str(error))) error_count += 1 except: error = sys.exc_info()[0] print("ERROR: {}".format(error)) error_count += 1 else: error_count = 0 finally: if error_count > 5: reboot_device() i = 0 led.write(1) time.sleep(0.1) led.write(0) i += 1 newsleep = (loopstart + PERIOD) - time.time() if newsleep < 0: print("WARNING: loop took {}s while period is {}!".format(PERIOD - newsleep, PERIOD)) else: time.sleep(newsleep)

f72a71fdb4445df86e6a963308c53723cb7372ed

py

Python

src/util/__init__.py

megemini/DataCastle2017

261134f760d8c1bbfc3e65e1362b7710e601947d

src/util/__init__.py

megemini/DataCastle2017

261134f760d8c1bbfc3e65e1362b7710e601947d

src/util/__init__.py

megemini/DataCastle2017

261134f760d8c1bbfc3e65e1362b7710e601947d

# import pandas as pd # import numpy as np

f72ad5b39fcaee399cd011abf25e5fda0c0342a6

py

Python

jina/flow/mixin/async_crud.py

liushuigs/jina

b3550e901b2a340924330b5ba2801603e493c933

jina/flow/mixin/async_crud.py

liushuigs/jina

b3550e901b2a340924330b5ba2801603e493c933

2021-02-15T01:40:38.000Z

2021-02-15T02:00:21.000Z

jina/flow/mixin/async_crud.py

liushuigs/jina

b3550e901b2a340924330b5ba2801603e493c933

import warnings from typing import Union, Iterable, TextIO, Dict, Optional import numpy as np from ...clients.base import InputType, CallbackFnType from ...enums import DataInputType from ...helper import deprecated_alias class AsyncCRUDFlowMixin: """The asynchronous version of the Mixin for CRUD in Flow""" @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def train( self, inputs: InputType, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Do training on the current Flow :param inputs: An iterator of bytes. If not given, then you have to specify it in **kwargs**. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ warnings.warn(f'{self.train} is under heavy refactoring', FutureWarning) async for r in self._get_client(**kwargs).train( inputs, on_done, on_error, on_always, **kwargs ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def index_ndarray( self, array: 'np.ndarray', axis: int = 0, size: Optional[int] = None, shuffle: bool = False, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Using numpy ndarray as the index source for the current Flow :param array: the numpy ndarray data source :param axis: iterate over that axis :param size: the maximum number of the sub arrays :param shuffle: shuffle the the numpy data source beforehand :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_ndarray async for r in self._get_client(**kwargs).index( _input_ndarray(array, axis, size, shuffle), on_done, on_error, on_always, data_type=DataInputType.CONTENT, **kwargs, ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def search_ndarray( self, array: 'np.ndarray', axis: int = 0, size: Optional[int] = None, shuffle: bool = False, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a numpy ndarray as the query source for searching on the current Flow :param array: the numpy ndarray data source :param axis: iterate over that axis :param size: the maximum number of the sub arrays :param shuffle: shuffle the the numpy data source beforehand :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_ndarray async for r in self._get_client(**kwargs).search( _input_ndarray(array, axis, size, shuffle), on_done, on_error, on_always, data_type=DataInputType.CONTENT, **kwargs, ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def index_lines( self, lines: Optional[Union[Iterable[str], TextIO]] = None, filepath: Optional[str] = None, size: Optional[int] = None, sampling_rate: Optional[float] = None, read_mode: str = 'r', line_format: str = 'json', field_resolver: Optional[Dict[str, str]] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a list of lines as the index source for indexing on the current Flow :param lines: a list of strings, each is considered as d document :param filepath: a text file that each line contains a document :param size: the maximum number of the documents :param sampling_rate: the sampling rate between [0, 1] :param read_mode: specifies the mode in which the file is opened. 'r' for reading in text mode, 'rb' for reading in binary :param line_format: the format of each line: ``json`` or ``csv`` :param field_resolver: a map from field names defined in ``document`` (JSON, dict) to the field names defined in Protobuf. This is only used when the given ``document`` is a JSON string or a Python dict. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_lines async for r in self._get_client(**kwargs).index( _input_lines( lines, filepath, size=size, sampling_rate=sampling_rate, read_mode=read_mode, line_format=line_format, field_resolver=field_resolver, ), on_done, on_error, on_always, data_type=DataInputType.AUTO, **kwargs, ): yield r async def index_csv( self, lines: Union[Iterable[str], TextIO], field_resolver: Dict[str, str] = None, size: Optional[int] = None, sampling_rate: Optional[float] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a list of lines as the index source for indexing on the current Flow :param lines: a list of strings, each is considered as d document :param size: the maximum number of the documents :param sampling_rate: the sampling rate between [0, 1] :param field_resolver: a map from field names defined in ``document`` (JSON, dict) to the field names defined in Protobuf. This is only used when the given ``document`` is a JSON string or a Python dict. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_csv async for r in self._get_client(**kwargs).index( _input_csv( lines, size=size, sampling_rate=sampling_rate, field_resolver=field_resolver, ), on_done, on_error, on_always, data_type=DataInputType.AUTO, **kwargs, ): yield r async def index_ndjson( self, lines: Union[Iterable[str], TextIO], field_resolver: Optional[Dict[str, str]] = None, size: Optional[int] = None, sampling_rate: Optional[float] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a list of lines as the index source for indexing on the current Flow :param lines: a list of strings, each is considered as d document :param size: the maximum number of the documents :param sampling_rate: the sampling rate between [0, 1] :param field_resolver: a map from field names defined in ``document`` (JSON, dict) to the field names defined in Protobuf. This is only used when the given ``document`` is a JSON string or a Python dict. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_ndjson async for r in self._get_client(**kwargs).index( _input_ndjson( lines, size=size, sampling_rate=sampling_rate, field_resolver=field_resolver, ), on_done, on_error, on_always, data_type=DataInputType.AUTO, **kwargs, ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def index_files( self, patterns: Union[str, Iterable[str]], recursive: bool = True, size: Optional[int] = None, sampling_rate: Optional[float] = None, read_mode: Optional[str] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a set of files as the index source for indexing on the current Flow :param patterns: The pattern may contain simple shell-style wildcards, e.g. '\*.py', '[\*.zip, \*.gz]' :param recursive: If recursive is true, the pattern '**' will match any files and zero or more directories and subdirectories. :param size: the maximum number of the files :param sampling_rate: the sampling rate between [0, 1] :param read_mode: specifies the mode in which the file is opened. 'r' for reading in text mode, 'rb' for reading in binary mode :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_files async for r in self._get_client(**kwargs).index( _input_files(patterns, recursive, size, sampling_rate, read_mode), on_done, on_error, on_always, data_type=DataInputType.CONTENT, **kwargs, ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def search_files( self, patterns: Union[str, Iterable[str]], recursive: bool = True, size: Optional[int] = None, sampling_rate: Optional[float] = None, read_mode: Optional[str] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a set of files as the query source for searching on the current Flow :param patterns: The pattern may contain simple shell-style wildcards, e.g. '\*.py', '[\*.zip, \*.gz]' :param recursive: If recursive is true, the pattern '**' will match any files and zero or more directories and subdirectories. :param size: the maximum number of the files :param sampling_rate: the sampling rate between [0, 1] :param read_mode: specifies the mode in which the file is opened. 'r' for reading in text mode, 'rb' for reading in :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_files async for r in self._get_client(**kwargs).search( _input_files(patterns, recursive, size, sampling_rate, read_mode), on_done, on_error, on_always, data_type=DataInputType.CONTENT, **kwargs, ): yield r async def search_ndjson( self, lines: Union[Iterable[str], TextIO], field_resolver: Optional[Dict[str, str]] = None, size: Optional[int] = None, sampling_rate: Optional[float] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a list of files as the query source for searching on the current Flow :param lines: a list of strings, each is considered as d document :param size: the maximum number of the documents :param sampling_rate: the sampling rate between [0, 1] :param field_resolver: a map from field names defined in ``document`` (JSON, dict) to the field names defined in Protobuf. This is only used when the given ``document`` is a JSON string or a Python dict. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_ndjson async for r in self._get_client(**kwargs).search( _input_ndjson( lines, size=size, sampling_rate=sampling_rate, field_resolver=field_resolver, ), on_done, on_error, on_always, data_type=DataInputType.AUTO, **kwargs, ): yield r async def search_csv( self, lines: Union[Iterable[str], TextIO], field_resolver: Optional[Dict[str, str]] = None, size: Optional[int] = None, sampling_rate: Optional[float] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a list of lines as the index source for indexing on the current Flow :param lines: a list of strings, each is considered as d document :param size: the maximum number of the documents :param sampling_rate: the sampling rate between [0, 1] :param field_resolver: a map from field names defined in ``document`` (JSON, dict) to the field names defined in Protobuf. This is only used when the given ``document`` is a JSON string or a Python dict. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_csv async for r in self._get_client(**kwargs).search( _input_csv( lines, size=size, sampling_rate=sampling_rate, field_resolver=field_resolver, ), on_done, on_error, on_always, data_type=DataInputType.AUTO, **kwargs, ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def search_lines( self, lines: Optional[Union[Iterable[str], TextIO]] = None, filepath: Optional[str] = None, size: Optional[int] = None, sampling_rate: Optional[float] = None, read_mode: str = 'r', line_format: str = 'json', field_resolver: Optional[Dict[str, str]] = None, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Use a list of files as the query source for searching on the current Flow :param filepath: a text file that each line contains a document :param lines: a list of strings, each is considered as d document :param size: the maximum number of the documents :param sampling_rate: the sampling rate between [0, 1] :param read_mode: specifies the mode in which the file is opened. 'r' for reading in text mode, 'rb' for reading in binary :param line_format: the format of each line: ``json`` or ``csv`` :param field_resolver: a map from field names defined in ``document`` (JSON, dict) to the field names defined in Protobuf. This is only used when the given ``document`` is a JSON string or a Python dict. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ from ...clients.sugary_io import _input_lines async for r in self._get_client(**kwargs).search( _input_lines( lines, filepath, size=size, sampling_rate=sampling_rate, read_mode=read_mode, line_format=line_format, field_resolver=field_resolver, ), on_done, on_error, on_always, data_type=DataInputType.CONTENT, **kwargs, ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def index( self, inputs: InputType, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Do indexing on the current Flow It will start a :py:class:`CLIClient` and call :py:func:`index`. :param inputs: An iterator of bytes. If not given, then you have to specify it in **kwargs**. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ async for r in self._get_client(**kwargs).index( inputs, on_done, on_error, on_always, **kwargs ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def update( self, inputs: InputType, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Do updates on the current Flow It will start a :py:class:`CLIClient` and call :py:func:`index`. :param inputs: An iterator of bytes. If not given, then you have to specify it in **kwargs**. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ async for r in self._get_client(**kwargs).update( inputs, on_done, on_error, on_always, **kwargs ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def delete( self, ids: Iterable[str], on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Do deletion on the current Flow :param ids: An iterable of ids :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ async for r in self._get_client(**kwargs).delete( ids, on_done, on_error, on_always, **kwargs ): yield r @deprecated_alias( input_fn=('inputs', 0), buffer=('inputs', 1), callback=('on_done', 1), output_fn=('on_done', 1), ) async def search( self, inputs: InputType, on_done: CallbackFnType = None, on_error: CallbackFnType = None, on_always: CallbackFnType = None, **kwargs, ): """Do searching on the current Flow It will start a :py:class:`CLIClient` and call :py:func:`search`. :param inputs: An iterator of bytes. If not given, then you have to specify it in **kwargs**. :param on_done: the function to be called when the :class:`Request` object is resolved. :param on_error: the function to be called when the :class:`Request` object is rejected. :param on_always: the function to be called when the :class:`Request` object is is either resolved or rejected. :param kwargs: accepts all keyword arguments of `jina client` CLI :yields: results """ async for r in self._get_client(**kwargs).search( inputs, on_done, on_error, on_always, **kwargs ): yield r

f72adc47d855b9bd8cfb880f4445828ea9fe2109

py

Python

pysot/datasets/dataset_template.py

wattanapong/DFA

c05851beca2f8739f80531eb4de2f61639715cab

pysot/datasets/dataset_template.py

wattanapong/DFA

c05851beca2f8739f80531eb4de2f61639715cab

pysot/datasets/dataset_template.py

wattanapong/DFA

c05851beca2f8739f80531eb4de2f61639715cab

# Copyright (c) SenseTime. All Rights Reserved. from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import json import logging import sys import os import cv2 import numpy as np from torch.utils.data import Dataset from pysot.utils.bbox import center2corner, Center from pysot.datasets.anchor_target import AnchorTarget from pysot.datasets.augmentation import Augmentation from pysot.core.config import cfg logger = logging.getLogger("global") # setting opencv pyv = sys.version[0] if pyv[0] == '3': cv2.ocl.setUseOpenCL(False) class SubDataset(object): def __init__(self, name, root, anno, frame_range, num_use, start_idx): cur_path = os.path.dirname(os.path.realpath(__file__)) self.name = name self.root = os.path.join(cur_path, '../../', root) self.anno = os.path.join(cur_path, '../../', anno) self.frame_range = frame_range self.num_use = num_use self.start_idx = start_idx logger.info("loading " + name) with open(self.anno, 'r') as f: meta_data = json.load(f) meta_data = self._filter_zero(meta_data) for video in list(meta_data.keys()): for track in meta_data[video]: frames = meta_data[video][track] frames = list(map(int, filter(lambda x: x.isdigit(), frames.keys()))) frames.sort() meta_data[video][track]['frames'] = frames if len(frames) <= 0: logger.warning("{}/{} has no frames".format(video, track)) del meta_data[video][track] for video in list(meta_data.keys()): if len(meta_data[video]) <= 0: logger.warning("{} has no tracks".format(video)) del meta_data[video] self.labels = meta_data self.num = len(self.labels) self.num_use = self.num if self.num_use == -1 else self.num_use self.videos = list(meta_data.keys()) logger.info("{} loaded".format(self.name)) self.path_format = '{}.{}.{}.jpg' self.pick = self.shuffle() def _filter_zero(self, meta_data): meta_data_new = {} for video, tracks in meta_data.items(): new_tracks = {} for trk, frames in tracks.items(): new_frames = {} for frm, bbox in frames.items(): if not isinstance(bbox, dict): if len(bbox) == 4: x1, y1, x2, y2 = bbox w, h = x2 - x1, y2 - y1 else: w, h = bbox if w <= 0 or h <= 0: continue new_frames[frm] = bbox if len(new_frames) > 0: new_tracks[trk] = new_frames if len(new_tracks) > 0: meta_data_new[video] = new_tracks return meta_data_new def log(self): logger.info("{} start-index {} select [{}/{}] path_format {}".format( self.name, self.start_idx, self.num_use, self.num, self.path_format)) def shuffle(self): lists = list(range(self.start_idx, self.start_idx + self.num)) pick = [] while len(pick) < self.num_use: np.random.shuffle(lists) pick += lists return pick[:self.num_use] def get_image_anno(self, video, track, frame): frame = "{:06d}".format(frame) image_path = os.path.join(self.root, video, self.path_format.format(frame, track, 'x')) image_anno = self.labels[video][track][frame] return image_path, image_anno # track is tracking object in video # video is one of subfolder under ILSVRC2015_VID_train_000{0-3}, for example, ILSVRC2015_train_00004000 def get_positive_pair(self, index): video_name = self.videos[index] video = self.labels[video_name] track = np.random.choice(list(video.keys())) track_info = video[track] frames = track_info['frames'] template_frame = np.random.randint(0, len(frames)) template_frame = frames[template_frame] return self.get_image_anno(video_name, track, template_frame) def get_random_target(self, index=-1): if index == -1: index = np.random.randint(0, self.num) video_name = self.videos[index] video = self.labels[video_name] track = np.random.choice(list(video.keys())) track_info = video[track] frames = track_info['frames'] frame = np.random.choice(frames) return self.get_image_anno(video_name, track, frame) def __len__(self): return self.num class TrkDataset(Dataset): def __init__(self,): super(TrkDataset, self).__init__() desired_size = (cfg.TRAIN.SEARCH_SIZE - cfg.TRAIN.EXEMPLAR_SIZE) / \ cfg.ANCHOR.STRIDE + 1 + cfg.TRAIN.BASE_SIZE if desired_size != cfg.TRAIN.OUTPUT_SIZE: raise Exception('size not match!') # create anchor target self.anchor_target = AnchorTarget() # create sub dataset self.all_dataset = [] start = 0 self.num = 0 for name in cfg.DATASET.NAMES: subdata_cfg = getattr(cfg.DATASET, name) sub_dataset = SubDataset( name, subdata_cfg.ROOT, subdata_cfg.ANNO, subdata_cfg.FRAME_RANGE, subdata_cfg.NUM_USE, start ) start += sub_dataset.num self.num += sub_dataset.num_use sub_dataset.log() self.all_dataset.append(sub_dataset) # data augmentation self.template_aug = Augmentation( cfg.DATASET.TEMPLATE.SHIFT, cfg.DATASET.TEMPLATE.SCALE, cfg.DATASET.TEMPLATE.BLUR, cfg.DATASET.TEMPLATE.FLIP, cfg.DATASET.TEMPLATE.COLOR ) self.search_aug = Augmentation( cfg.DATASET.SEARCH.SHIFT, cfg.DATASET.SEARCH.SCALE, cfg.DATASET.SEARCH.BLUR, cfg.DATASET.SEARCH.FLIP, cfg.DATASET.SEARCH.COLOR ) videos_per_epoch = cfg.DATASET.VIDEOS_PER_EPOCH self.num = videos_per_epoch if videos_per_epoch > 0 else self.num self.num *= cfg.TRAIN.EPOCH self.pick = self.shuffle() def shuffle(self): pick = [] m = 0 while m < self.num: p = [] for sub_dataset in self.all_dataset: sub_p = sub_dataset.pick p += sub_p np.random.shuffle(p) pick += p m = len(pick) logger.info("shuffle done!") logger.info("dataset length {}".format(self.num)) return pick[:self.num] def _find_dataset(self, index): for dataset in self.all_dataset: if dataset.start_idx + dataset.num > index: return dataset, index - dataset.start_idx def _get_bbox(self, image, shape): imh, imw = image.shape[:2] if len(shape) == 4: w, h = shape[2]-shape[0], shape[3]-shape[1] else: w, h = shape context_amount = 0.5 exemplar_size = cfg.TRAIN.EXEMPLAR_SIZE wc_z = w + context_amount * (w+h) hc_z = h + context_amount * (w+h) s_z = np.sqrt(wc_z * hc_z) scale_z = exemplar_size / s_z w = w*scale_z h = h*scale_z cx, cy = imw//2, imh//2 bbox = center2corner(Center(cx, cy, w, h)) return bbox def __len__(self): return self.num def __getitem__(self, index): index = self.pick[index] dataset, index = self._find_dataset(index) gray = cfg.DATASET.GRAY and cfg.DATASET.GRAY > np.random.random() neg = cfg.DATASET.NEG and cfg.DATASET.NEG > np.random.random() # get one dataset if neg: print('please check this suspension due to it was removed negative function (distractor)') import pdb pdb.set_trace() template = dataset.get_random_target(index) search = np.random.choice(self.all_dataset).get_random_target() else: template = dataset.get_positive_pair(index) if not os.path.exists(template[0]): print(template[0]) # get image template_image = cv2.imread(template[0]) # get bounding box template_box = self._get_bbox(template_image, template[1]) # augmentation template, _ = self.template_aug(template_image, template_box, cfg.TRAIN.EXEMPLAR_SIZE, gray=gray) template = template.transpose((2, 0, 1)).astype(np.float32) return { 'template': template, 'gt': template_box }

f72b094590d5184ffbaf3cd4a122b4c8a53db388

py

Python

sdk/containerregistry/azure-mgmt-containerregistry/azure/mgmt/containerregistry/v2020_11_01_preview/_container_registry_management_client.py

vincenttran-msft/azure-sdk-for-python

348b56f9f03eeb3f7b502eed51daf494ffff874d

2021-09-07T18:39:05.000Z

2021-09-07T18:39:05.000Z

sdk/containerregistry/azure-mgmt-containerregistry/azure/mgmt/containerregistry/v2020_11_01_preview/_container_registry_management_client.py

vincenttran-msft/azure-sdk-for-python

348b56f9f03eeb3f7b502eed51daf494ffff874d

sdk/containerregistry/azure-mgmt-containerregistry/azure/mgmt/containerregistry/v2020_11_01_preview/_container_registry_management_client.py

vincenttran-msft/azure-sdk-for-python

348b56f9f03eeb3f7b502eed51daf494ffff874d

2022-03-04T06:21:56.000Z

2022-03-04T06:21:56.000Z

# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from copy import deepcopy from typing import Any, Optional, TYPE_CHECKING from azure.core.rest import HttpRequest, HttpResponse from azure.mgmt.core import ARMPipelineClient from msrest import Deserializer, Serializer from . import models from ._configuration import ContainerRegistryManagementClientConfiguration from .operations import ConnectedRegistriesOperations, ExportPipelinesOperations, ImportPipelinesOperations, Operations, PipelineRunsOperations, PrivateEndpointConnectionsOperations, RegistriesOperations, ReplicationsOperations, ScopeMapsOperations, TokensOperations, WebhooksOperations if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports from azure.core.credentials import TokenCredential class ContainerRegistryManagementClient: """ContainerRegistryManagementClient. :ivar connected_registries: ConnectedRegistriesOperations operations :vartype connected_registries: azure.mgmt.containerregistry.v2020_11_01_preview.operations.ConnectedRegistriesOperations :ivar export_pipelines: ExportPipelinesOperations operations :vartype export_pipelines: azure.mgmt.containerregistry.v2020_11_01_preview.operations.ExportPipelinesOperations :ivar registries: RegistriesOperations operations :vartype registries: azure.mgmt.containerregistry.v2020_11_01_preview.operations.RegistriesOperations :ivar import_pipelines: ImportPipelinesOperations operations :vartype import_pipelines: azure.mgmt.containerregistry.v2020_11_01_preview.operations.ImportPipelinesOperations :ivar operations: Operations operations :vartype operations: azure.mgmt.containerregistry.v2020_11_01_preview.operations.Operations :ivar pipeline_runs: PipelineRunsOperations operations :vartype pipeline_runs: azure.mgmt.containerregistry.v2020_11_01_preview.operations.PipelineRunsOperations :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations :vartype private_endpoint_connections: azure.mgmt.containerregistry.v2020_11_01_preview.operations.PrivateEndpointConnectionsOperations :ivar replications: ReplicationsOperations operations :vartype replications: azure.mgmt.containerregistry.v2020_11_01_preview.operations.ReplicationsOperations :ivar scope_maps: ScopeMapsOperations operations :vartype scope_maps: azure.mgmt.containerregistry.v2020_11_01_preview.operations.ScopeMapsOperations :ivar tokens: TokensOperations operations :vartype tokens: azure.mgmt.containerregistry.v2020_11_01_preview.operations.TokensOperations :ivar webhooks: WebhooksOperations operations :vartype webhooks: azure.mgmt.containerregistry.v2020_11_01_preview.operations.WebhooksOperations :param credential: Credential needed for the client to connect to Azure. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: The Microsoft Azure subscription ID. :type subscription_id: str :param base_url: Service URL. Default value is 'https://management.azure.com'. :type base_url: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. """ def __init__( self, credential: "TokenCredential", subscription_id: str, base_url: str = "https://management.azure.com", **kwargs: Any ) -> None: self._config = ContainerRegistryManagementClientConfiguration(credential=credential, subscription_id=subscription_id, **kwargs) self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False self.connected_registries = ConnectedRegistriesOperations(self._client, self._config, self._serialize, self._deserialize) self.export_pipelines = ExportPipelinesOperations(self._client, self._config, self._serialize, self._deserialize) self.registries = RegistriesOperations(self._client, self._config, self._serialize, self._deserialize) self.import_pipelines = ImportPipelinesOperations(self._client, self._config, self._serialize, self._deserialize) self.operations = Operations(self._client, self._config, self._serialize, self._deserialize) self.pipeline_runs = PipelineRunsOperations(self._client, self._config, self._serialize, self._deserialize) self.private_endpoint_connections = PrivateEndpointConnectionsOperations(self._client, self._config, self._serialize, self._deserialize) self.replications = ReplicationsOperations(self._client, self._config, self._serialize, self._deserialize) self.scope_maps = ScopeMapsOperations(self._client, self._config, self._serialize, self._deserialize) self.tokens = TokensOperations(self._client, self._config, self._serialize, self._deserialize) self.webhooks = WebhooksOperations(self._client, self._config, self._serialize, self._deserialize) def _send_request( self, request, # type: HttpRequest **kwargs: Any ) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest >>> request = HttpRequest("GET", "https://www.example.org/") <HttpRequest [GET], url: 'https://www.example.org/'> >>> response = client._send_request(request) <HttpResponse: 200 OK> For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart :param request: The network request you want to make. Required. :type request: ~azure.core.rest.HttpRequest :keyword bool stream: Whether the response payload will be streamed. Defaults to False. :return: The response of your network call. Does not do error handling on your response. :rtype: ~azure.core.rest.HttpResponse """ request_copy = deepcopy(request) request_copy.url = self._client.format_url(request_copy.url) return self._client.send_request(request_copy, **kwargs) def close(self): # type: () -> None self._client.close() def __enter__(self): # type: () -> ContainerRegistryManagementClient self._client.__enter__() return self def __exit__(self, *exc_details): # type: (Any) -> None self._client.__exit__(*exc_details)

f72b319c6f56785827dd2160e2b9d041dde23ada

py

Python

experiments/ashvin/icml2020/hand/brac/test_video1.py

Asap7772/railrl_evalsawyer

baba8ce634d32a48c7dfe4dc03b123e18e96e0a3

experiments/ashvin/icml2020/hand/brac/test_video1.py

Asap7772/railrl_evalsawyer

baba8ce634d32a48c7dfe4dc03b123e18e96e0a3

experiments/ashvin/icml2020/hand/brac/test_video1.py

Asap7772/railrl_evalsawyer

baba8ce634d32a48c7dfe4dc03b123e18e96e0a3

""" AWR + SAC from demo experiment """ from rlkit.demos.source.dict_to_mdp_path_loader import DictToMDPPathLoader from rlkit.launchers.experiments.awac.awac_rl import experiment, process_args import rlkit.misc.hyperparameter as hyp from rlkit.launchers.arglauncher import run_variants from rlkit.torch.sac.policies import GaussianPolicy from rlkit.torch.networks import Clamp if __name__ == "__main__": variant = dict( num_epochs=5001, num_eval_steps_per_epoch=1000, num_trains_per_train_loop=1000, num_expl_steps_per_train_loop=1000, min_num_steps_before_training=1000, max_path_length=1000, batch_size=1024, replay_buffer_size=int(1E6), layer_size=256, policy_class=GaussianPolicy, policy_kwargs=dict( hidden_sizes=[256, 256, 256, 256], max_log_std=0, min_log_std=-6, std_architecture="values", # num_gaussians=1, ), qf_kwargs=dict( hidden_sizes=[256, 256, ], ), algorithm="SAC", version="normal", collection_mode='batch', trainer_kwargs=dict( discount=0.99, soft_target_tau=5e-3, target_update_period=1, policy_lr=3E-4, qf_lr=3E-4, reward_scale=1, beta=1, use_automatic_entropy_tuning=False, alpha=0, compute_bc=False, bc_num_pretrain_steps=0, q_num_pretrain1_steps=0, q_num_pretrain2_steps=25000, policy_weight_decay=1e-4, q_weight_decay=0, bc_loss_type="mse", rl_weight=1.0, use_awr_update=True, use_reparam_update=False, reparam_weight=0.0, awr_weight=0.0, bc_weight=1.0, post_bc_pretrain_hyperparams=dict( bc_weight=0.0, compute_bc=False, ), brac=True, reward_transform_kwargs=None, # r' = r + 1 terminal_transform_kwargs=None, # t = 0 ), launcher_config=dict( num_exps_per_instance=1, region='us-west-2', ), path_loader_class=DictToMDPPathLoader, path_loader_kwargs=dict( obs_key="state_observation", demo_paths=[ # dict( # path="demos/icml2020/hand/pen2_sparse.npy", # obs_dict=True, # is_demo=True, # ), # dict( # path="demos/icml2020/hand/pen_bc5.npy", # obs_dict=False, # is_demo=False, # train_split=0.9, # ), ], ), add_env_demos=True, add_env_offpolicy_data=True, save_video=True, image_env_kwargs=dict( imsize=84, init_camera=None, # the environment initializes the camera already transpose=True, normalize=True, recompute_reward=False, non_presampled_goal_img_is_garbage=True, # do not set_to_goal ), dump_video_kwargs=dict( exploration_goal_image_key="image_observation", evaluation_goal_image_key="image_observation", image_format="CWH", ), # renderer_kwargs=dict( # # width=84, # # height=84, # init_camera=None, # the environment initializes the camera already # # transpose=True, # create_image_format="HWC", # output_image_format="CHW", # # normalize=True, # ), # logger_variant=dict( # tensorboard=True, # ), load_demos=True, pretrain_policy=True, pretrain_rl=True, # save_pretrained_algorithm=True, # snapshot_mode="all", ) search_space = { 'env': ["relocate-binary-old-v0", ], 'trainer_kwargs.bc_loss_type': ["mle"], 'trainer_kwargs.awr_loss_type': ["mle"], 'seedid': range(3), 'trainer_kwargs.beta': [0.1, ], 'trainer_kwargs.reparam_weight': [0.0, ], 'trainer_kwargs.awr_weight': [1.0], 'trainer_kwargs.bc_weight': [1.0, ], 'policy_kwargs.std_architecture': ["values", ], 'trainer_kwargs.clip_score': [2, ], # 'trainer_kwargs.compute_bc': [True, ], 'trainer_kwargs.awr_use_mle_for_vf': [True, ], 'trainer_kwargs.awr_sample_actions': [False, ], 'trainer_kwargs.awr_min_q': [True, ], 'trainer_kwargs.q_weight_decay': [0, ], 'trainer_kwargs.reward_transform_kwargs': [None, ], 'trainer_kwargs.terminal_transform_kwargs': [dict(m=0, b=0), ], 'qf_kwargs.output_activation': [Clamp(max=0)], 'trainer_kwargs.train_bc_on_rl_buffer':[True], # 'policy_kwargs.num_gaussians': [1, ], } sweeper = hyp.DeterministicHyperparameterSweeper( search_space, default_parameters=variant, ) variants = [] for variant in sweeper.iterate_hyperparameters(): variants.append(variant) run_variants(experiment, variants, process_args)

f72bac46a7bf89e92fd86af932bfe8a7135e61d2

py

Python

src/sardana/util/funcgenerator.py

schooft/sardana

76287b416650f40da79871ee3849340d0ff31f1d

src/sardana/util/funcgenerator.py

schooft/sardana

76287b416650f40da79871ee3849340d0ff31f1d

src/sardana/util/funcgenerator.py

schooft/sardana

76287b416650f40da79871ee3849340d0ff31f1d

############################################################################## ## # This file is part of Sardana ## # http://www.sardana-controls.org/ ## # Copyright 2011 CELLS / ALBA Synchrotron, Bellaterra, Spain ## # Sardana is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. ## # Sardana is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Lesser General Public License for more details. ## # You should have received a copy of the GNU Lesser General Public License # along with Sardana. If not, see <http://www.gnu.org/licenses/>. ## ############################################################################## import time import threading import math import copy import numpy import traceback from sardana import State from sardana.sardanaevent import EventGenerator, EventType from sardana.pool.pooldefs import SynchParam, SynchDomain from taurus.core.util.log import Logger def strictly_increasing(l): """Check whether list l has strictly increasing values""" return all(x < y for x, y in zip(l, l[1:])) def strictly_decreasing(l): """Check whether list l has strictly deacreasing values""" return all(x > y for x, y in zip(l, l[1:])) class FunctionGenerator(EventGenerator, Logger): """Generator of active and passive events describing a rectangular function. .. note:: The FunctionGenerator class has been included in Sardana on a provisional basis. Backwards incompatible changes (up to and including removal of the module) may occur if deemed necessary by the core developers. """ MAX_NAP_TIME = 0.1 def __init__(self, name="FunctionGenerator"): EventGenerator.__init__(self) Logger.__init__(self, name) self._name = name self._initial_domain = None self._active_domain = None self._position_event = threading.Event() self._position = None self._initial_domain_in_use = None self._active_domain_in_use = None self._active_events = list() self._passive_events = list() self._started = False self._stopped = False self._running = False self._start_time = None self._direction = None self._condition = None self._id = None self._start_fired = False def get_name(self): return self._name name = property(get_name) def set_initial_domain(self, domain): self._initial_domain = domain def get_initial_domain(self): return self._initial_domain initial_domain = property(get_initial_domain, set_initial_domain) def set_active_domain(self, domain): self._active_domain = domain def get_active_domain(self): return self._active_domain active_domain = property(get_active_domain, set_active_domain) def set_initial_domain_in_use(self, domain): self._initial_domain_in_use = domain def get_initial_domain_in_use(self): return self._initial_domain_in_use initial_domain_in_use = property(get_initial_domain_in_use, set_initial_domain_in_use) def set_active_domain_in_use(self, domain): self._active_domain_in_use = domain def get_active_domain_in_use(self): return self._active_domain_in_use active_domain_in_use = property(get_active_domain_in_use, set_active_domain_in_use) def add_active_event(self, event): self._active_events.append(event) def set_active_events(self, events): self._active_events = events def get_active_events(self): return self._active_events active_events = property(get_active_events, set_active_events) def add_passive_event(self, event): self._passive_events.append(event) def set_passive_events(self, events): self._passive_events = events def get_passive_events(self): return self._passive_events passive_events = property(get_passive_events, set_passive_events) def set_direction(self, direction): self._direction = direction if direction == 1: self._condition = numpy.greater_equal elif direction == -1: self._condition = numpy.less_equal else: raise ValueError("direction can be -1 or 1 (negative or positive)") def get_direction(self): return self._direction direction = property(get_direction, set_direction) def event_received(self, *args, **kwargs): _, _, v = args if v.error: exc_info = v.exc_info self.error("Synchronization base attribute in error") msg = "Details: " + "".join(traceback.format_exception(*exc_info)) self.debug(msg) return self._position = v.value self._position_event.set() def start(self): self._start_time = time.time() self._stopped = False self._started = True self._position = None self._start_fired = False self._position_event.clear() self._id = 0 self.fire_event(EventType("state"), State.Moving) def stop(self): self._stopped = True def is_started(self): return self._started def is_stopped(self): return self._stopped def is_running(self): return self._running def run(self): self._running = True try: while len(self.active_events) > 0 and not self.is_stopped(): self.wait_active() self.fire_active() self.wait_passive() self.fire_passive() self._id += 1 finally: self._started = False self._running = False self._stopped = False self.fire_event(EventType("state"), State.On) def sleep(self, period): if period <= 0: return necessary_naps = int(math.ceil(period / self.MAX_NAP_TIME)) if necessary_naps == 0: # avoid zero ZeroDivisionError nap = 0 else: nap = period / necessary_naps for _ in xrange(necessary_naps): if self.is_stopped(): break time.sleep(nap) def fire_start(self): self.fire_event(EventType("start"), self._id) self._start_fired = True if self._id > 0: msg = "start was fired with {0} delay".format(self._id) self.warning(msg) def wait_active(self): candidate = self.active_events[0] if self.initial_domain_in_use == SynchDomain.Time: now = time.time() candidate += self._start_time self.sleep(candidate - now) else: while True: if self.is_stopped(): break if self._position_event.isSet(): self._position_event.clear() now = self._position if self._condition(now, candidate): break else: self._position_event.wait(self.MAX_NAP_TIME) def fire_active(self): # check if some events needs to be skipped i = 0 while i < len(self.active_events) - 1: candidate = self.active_events[i + 1] if self.initial_domain_in_use is SynchDomain.Time: candidate += self._start_time now = time.time() elif self.initial_domain_in_use is SynchDomain.Position: now = self._position if self._condition(now, candidate): i += 1 else: break self._id += i if not self._start_fired: self.fire_start() self.fire_event(EventType("active"), self._id) self.active_events = self.active_events[i + 1:] self.passive_events = self.passive_events[i:] def wait_passive(self): if self.active_domain_in_use == SynchDomain.Time: now = time.time() candidate = self._start_time + self.passive_events[0] self.sleep(candidate - now) else: while True: if self._position_event.isSet(): self._position_event.clear() if self._condition(self._position, self.passive_events[0]): break else: self._position_event.wait(self.MAX_NAP_TIME) if self.is_stopped(): break def fire_passive(self): self.fire_event(EventType("passive"), self._id) self.set_passive_events(self.passive_events[1:]) if len(self.passive_events) == 0: self.fire_end() def fire_end(self): self.fire_event(EventType("end"), self._id) def set_configuration(self, configuration): # make a copy since we may inject the initial time configuration = copy.deepcopy(configuration) active_events = [] passive_events = [] self._direction = None # create short variables for commodity Time = SynchDomain.Time Position = SynchDomain.Position Initial = SynchParam.Initial Delay = SynchParam.Delay Active = SynchParam.Active Total = SynchParam.Total Repeats = SynchParam.Repeats for i, group in enumerate(configuration): # inject delay as initial time - generation will be # relative to the start time initial_param = group.get(Initial) if initial_param is None: initial_param = dict() if Time not in initial_param: delay_param = group.get(Delay) if Time in delay_param: initial_param[Time] = delay_param[Time] group[Initial] = initial_param # determine active domain in use msg = "no initial value in group %d" % i if self.initial_domain in initial_param: self.initial_domain_in_use = self.initial_domain elif Position in initial_param: self.initial_domain_in_use = Position elif Time in initial_param: self.initial_domain_in_use = Time else: raise ValueError(msg) # determine passive domain in use active_param = group.get(Active) msg = "no active value in group %d" % i if self.active_domain is None: if Time in active_param: self.active_domain_in_use = Time elif Position in active_param: self.active_domain_in_use = Position else: raise ValueError(msg) elif self.active_domain in active_param: self.active_domain_in_use = self.active_domain else: raise ValueError(msg) # create short variables for commodity initial_domain_in_use = self.initial_domain_in_use active_domain_in_use = self.active_domain_in_use repeats = group.get(Repeats, 1) active = active_param[active_domain_in_use] initial_in_initial_domain = initial_param[initial_domain_in_use] initial_in_active_domain = initial_param[active_domain_in_use] active_event_in_initial_domain = initial_in_initial_domain active_event_in_active_domain = initial_in_active_domain if repeats > 1: total_param = group[Total] total_in_initial_domain = total_param[initial_domain_in_use] total_in_active_domain = total_param[active_domain_in_use] for _ in xrange(repeats): passive_event = active_event_in_active_domain + active active_events.append(active_event_in_initial_domain) passive_events.append(passive_event) active_event_in_initial_domain += total_in_initial_domain active_event_in_active_domain += total_in_active_domain else: active_events.append(active_event_in_initial_domain) passive_event = active_event_in_active_domain + active passive_events.append(passive_event) # determine direction if self.direction is None: if strictly_increasing(active_events): self.direction = 1 elif strictly_decreasing(active_events): self.direction = -1 else: msg = "active values indicate contradictory directions" raise ValueError(msg) self.active_events = active_events self.passive_events = passive_events

f72badfdcc7c9b8294a786b553d4648ee517ad6c

py

Python

tests/python/pants_test/util/test_contextutil.py

ghthor/pants

450de702414f87f563081ddefaefd8a554de07a3

tests/python/pants_test/util/test_contextutil.py

ghthor/pants

450de702414f87f563081ddefaefd8a554de07a3

tests/python/pants_test/util/test_contextutil.py

ghthor/pants

450de702414f87f563081ddefaefd8a554de07a3

# coding=utf-8 # Copyright 2014 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import absolute_import, division, print_function, unicode_literals import os import pstats import shutil import signal import sys import unittest import uuid import zipfile from builtins import next, object, range, str from contextlib import contextmanager import mock from pants.util.contextutil import (HardSystemExit, InvalidZipPath, Timer, environment_as, exception_logging, hard_exit_handler, hermetic_environment_as, maybe_profiled, open_zip, pushd, signal_handler_as, stdio_as, temporary_dir, temporary_file) from pants.util.process_handler import subprocess PATCH_OPTS = dict(autospec=True, spec_set=True) class ContextutilTest(unittest.TestCase): def test_empty_environment(self): with environment_as(): pass def test_override_single_variable(self): with temporary_file() as output: # test that the override takes place with environment_as(HORK='BORK'): subprocess.Popen([sys.executable, '-c', 'import os; print(os.environ["HORK"])'], stdout=output).wait() output.seek(0) self.assertEquals('BORK\n', output.read()) # test that the variable is cleared with temporary_file() as new_output: subprocess.Popen([sys.executable, '-c', 'import os; print("HORK" in os.environ)'], stdout=new_output).wait() new_output.seek(0) self.assertEquals('False\n', new_output.read()) def test_environment_negation(self): with temporary_file() as output: with environment_as(HORK='BORK'): with environment_as(HORK=None): # test that the variable is cleared subprocess.Popen([sys.executable, '-c', 'import os; print("HORK" in os.environ)'], stdout=output).wait() output.seek(0) self.assertEquals('False\n', output.read()) def test_hermetic_environment(self): self.assertIn('USER', os.environ) with hermetic_environment_as(**{}): self.assertNotIn('USER', os.environ) def test_hermetic_environment_subprocesses(self): self.assertIn('USER', os.environ) with hermetic_environment_as(**dict(AAA='333')): output = subprocess.check_output('env', shell=True) self.assertNotIn('USER=', output) self.assertIn('AAA', os.environ) self.assertEquals(os.environ['AAA'], '333') self.assertIn('USER', os.environ) self.assertNotIn('AAA', os.environ) def test_hermetic_environment_unicode(self): UNICODE_CHAR = '¡' ENCODED_CHAR = UNICODE_CHAR.encode('utf-8') with environment_as(**dict(XXX=UNICODE_CHAR)): self.assertEquals(os.environ['XXX'], ENCODED_CHAR) with hermetic_environment_as(**dict(AAA=UNICODE_CHAR)): self.assertIn('AAA', os.environ) self.assertEquals(os.environ['AAA'], ENCODED_CHAR) self.assertEquals(os.environ['XXX'], ENCODED_CHAR) def test_simple_pushd(self): pre_cwd = os.getcwd() with temporary_dir() as tempdir: with pushd(tempdir) as path: self.assertEquals(tempdir, path) self.assertEquals(os.path.realpath(tempdir), os.getcwd()) self.assertEquals(pre_cwd, os.getcwd()) self.assertEquals(pre_cwd, os.getcwd()) def test_nested_pushd(self): pre_cwd = os.getcwd() with temporary_dir() as tempdir1: with pushd(tempdir1): self.assertEquals(os.path.realpath(tempdir1), os.getcwd()) with temporary_dir(root_dir=tempdir1) as tempdir2: with pushd(tempdir2): self.assertEquals(os.path.realpath(tempdir2), os.getcwd()) self.assertEquals(os.path.realpath(tempdir1), os.getcwd()) self.assertEquals(os.path.realpath(tempdir1), os.getcwd()) self.assertEquals(pre_cwd, os.getcwd()) self.assertEquals(pre_cwd, os.getcwd()) def test_temporary_file_no_args(self): with temporary_file() as fp: self.assertTrue(os.path.exists(fp.name), 'Temporary file should exist within the context.') self.assertTrue(os.path.exists(fp.name) == False, 'Temporary file should not exist outside of the context.') def test_temporary_file_without_cleanup(self): with temporary_file(cleanup=False) as fp: self.assertTrue(os.path.exists(fp.name), 'Temporary file should exist within the context.') self.assertTrue(os.path.exists(fp.name), 'Temporary file should exist outside of context if cleanup=False.') os.unlink(fp.name) def test_temporary_file_within_other_dir(self): with temporary_dir() as path: with temporary_file(root_dir=path) as f: self.assertTrue(os.path.realpath(f.name).startswith(os.path.realpath(path)), 'file should be created in root_dir if specified.') def test_temporary_dir_no_args(self): with temporary_dir() as path: self.assertTrue(os.path.exists(path), 'Temporary dir should exist within the context.') self.assertTrue(os.path.isdir(path), 'Temporary dir should be a dir and not a file.') self.assertFalse(os.path.exists(path), 'Temporary dir should not exist outside of the context.') def test_temporary_dir_without_cleanup(self): with temporary_dir(cleanup=False) as path: self.assertTrue(os.path.exists(path), 'Temporary dir should exist within the context.') self.assertTrue(os.path.exists(path), 'Temporary dir should exist outside of context if cleanup=False.') shutil.rmtree(path) def test_temporary_dir_with_root_dir(self): with temporary_dir() as path1: with temporary_dir(root_dir=path1) as path2: self.assertTrue(os.path.realpath(path2).startswith(os.path.realpath(path1)), 'Nested temporary dir should be created within outer dir.') def test_timer(self): class FakeClock(object): def __init__(self): self._time = 0.0 def time(self): ret = self._time self._time += 0.0001 # Force a little time to elapse. return ret def sleep(self, duration): self._time += duration clock = FakeClock() # Note: to test with the real system clock, use this instead: # import time # clock = time with Timer(clock=clock) as t: self.assertLess(t.start, clock.time()) self.assertGreater(t.elapsed, 0) clock.sleep(0.1) self.assertGreater(t.elapsed, 0.1) clock.sleep(0.1) self.assertTrue(t.finish is None) self.assertGreater(t.elapsed, 0.2) self.assertLess(t.finish, clock.time()) def test_open_zipDefault(self): with temporary_dir() as tempdir: with open_zip(os.path.join(tempdir, 'test'), 'w') as zf: self.assertTrue(zf._allowZip64) def test_open_zipTrue(self): with temporary_dir() as tempdir: with open_zip(os.path.join(tempdir, 'test'), 'w', allowZip64=True) as zf: self.assertTrue(zf._allowZip64) def test_open_zipFalse(self): with temporary_dir() as tempdir: with open_zip(os.path.join(tempdir, 'test'), 'w', allowZip64=False) as zf: self.assertFalse(zf._allowZip64) def test_open_zip_raises_exception_on_falsey_paths(self): falsey = (None, '', False) for invalid in falsey: with self.assertRaises(InvalidZipPath): next(open_zip(invalid).gen) def test_open_zip_returns_realpath_on_badzipfile(self): # In case of file corruption, deleting a Pants-constructed symlink would not resolve the error. with temporary_file() as not_zip: with temporary_dir() as tempdir: file_symlink = os.path.join(tempdir, 'foo') os.symlink(not_zip.name, file_symlink) self.assertEquals(os.path.realpath(file_symlink), os.path.realpath(not_zip.name)) with self.assertRaisesRegexp(zipfile.BadZipfile, r'{}'.format(not_zip.name)): next(open_zip(file_symlink).gen) @contextmanager def _stdio_as_tempfiles(self): """Harness to replace `sys.std*` with tempfiles. Validates that all files are read/written/flushed correctly, and acts as a contextmanager to allow for recursive tests. """ # Prefix contents written within this instance with a unique string to differentiate # them from other instances. uuid_str = str(uuid.uuid4()) def u(string): return '{}#{}'.format(uuid_str, string) stdin_data = u('stdio') stdout_data = u('stdout') stderr_data = u('stderr') with temporary_file() as tmp_stdin,\ temporary_file() as tmp_stdout,\ temporary_file() as tmp_stderr: print(stdin_data, file=tmp_stdin) tmp_stdin.seek(0) # Read prepared content from stdin, and write content to stdout/stderr. with stdio_as(stdout_fd=tmp_stdout.fileno(), stderr_fd=tmp_stderr.fileno(), stdin_fd=tmp_stdin.fileno()): self.assertEquals(sys.stdin.fileno(), 0) self.assertEquals(sys.stdout.fileno(), 1) self.assertEquals(sys.stderr.fileno(), 2) self.assertEquals(stdin_data, sys.stdin.read().strip()) print(stdout_data, file=sys.stdout) yield print(stderr_data, file=sys.stderr) tmp_stdout.seek(0) tmp_stderr.seek(0) self.assertEquals(stdout_data, tmp_stdout.read().strip()) self.assertEquals(stderr_data, tmp_stderr.read().strip()) def test_stdio_as(self): self.assertTrue(sys.stderr.fileno() > 2, "Expected a pseudofile as stderr, got: {}".format(sys.stderr)) old_stdout, old_stderr, old_stdin = sys.stdout, sys.stderr, sys.stdin # The first level tests that when `sys.std*` are file-likes (in particular, the ones set up in # pytest's harness) rather than actual files, we stash and restore them properly. with self._stdio_as_tempfiles(): # The second level stashes the first level's actual file objects and then re-opens them. with self._stdio_as_tempfiles(): pass # Validate that after the second level completes, the first level still sees valid # fds on `sys.std*`. self.assertEquals(sys.stdin.fileno(), 0) self.assertEquals(sys.stdout.fileno(), 1) self.assertEquals(sys.stderr.fileno(), 2) self.assertEquals(sys.stdout, old_stdout) self.assertEquals(sys.stderr, old_stderr) self.assertEquals(sys.stdin, old_stdin) def test_stdio_as_dev_null(self): # Capture output to tempfiles. with self._stdio_as_tempfiles(): # Read/write from/to `/dev/null`, which will be validated by the harness as not # affecting the tempfiles. with stdio_as(stdout_fd=-1, stderr_fd=-1, stdin_fd=-1): self.assertEquals(b'', sys.stdin.read()) print('garbage', file=sys.stdout) print('garbage', file=sys.stderr) def test_signal_handler_as(self): mock_initial_handler = 1 mock_new_handler = 2 with mock.patch('signal.signal', **PATCH_OPTS) as mock_signal: mock_signal.return_value = mock_initial_handler try: with signal_handler_as(signal.SIGUSR2, mock_new_handler): raise NotImplementedError('blah') except NotImplementedError: pass self.assertEquals(mock_signal.call_count, 2) mock_signal.assert_has_calls([ mock.call(signal.SIGUSR2, mock_new_handler), mock.call(signal.SIGUSR2, mock_initial_handler) ]) def test_permissions(self): with temporary_file(permissions=0o700) as f: self.assertEquals(0o700, os.stat(f.name)[0] & 0o777) with temporary_dir(permissions=0o644) as path: self.assertEquals(0o644, os.stat(path)[0] & 0o777) def test_exception_logging(self): fake_logger = mock.Mock() with self.assertRaises(AssertionError): with exception_logging(fake_logger, 'error!'): assert True is False fake_logger.exception.assert_called_once_with('error!') def test_maybe_profiled(self): with temporary_dir() as td: profile_path = os.path.join(td, 'profile.prof') with maybe_profiled(profile_path): for _ in range(5): print('test') # Ensure the profile data was written. self.assertTrue(os.path.exists(profile_path)) # Ensure the profile data is valid. pstats.Stats(profile_path).print_stats() def test_hard_exit_handler(self): with mock.patch('os._exit', **PATCH_OPTS) as mock_exit: with hard_exit_handler(): raise HardSystemExit() mock_exit.assert_called_once_with(0)

f72bca982790961f6bbe8bc31f1a60032438e1a2

py

Python

chat_assistant/chat_assistant_app/urls.py

mrhegemon/Rasa_zero_rpc_XR_bot

a468cc1f2b1a4e935ce18e97dcb7a11070bbea0b

2021-06-21T10:44:51.000Z

2021-06-21T10:44:51.000Z

chat_assistant/chat_assistant_app/urls.py

mrhegemon/Rasa_zero_rpc_XR_bot

a468cc1f2b1a4e935ce18e97dcb7a11070bbea0b

chat_assistant/chat_assistant_app/urls.py

mrhegemon/Rasa_zero_rpc_XR_bot

a468cc1f2b1a4e935ce18e97dcb7a11070bbea0b

2021-06-07T23:09:30.000Z

2021-06-07T23:09:30.000Z

from django.conf.urls import url from . import views urlpatterns = [ url('', views.chat, name='chat'), url('^chat/', views.chat, name='chat'), ]

f72bd257412e17141e60758b6a2232418acfb73b

py

Python

sdks/python/test/test_PurgeResponse.py

Brantone/appcenter-sdks

eeb063ecf79908b6e341fb00196d2cd9dc8f3262

sdks/python/test/test_PurgeResponse.py

Brantone/appcenter-sdks

eeb063ecf79908b6e341fb00196d2cd9dc8f3262

2019-10-23T06:38:53.000Z

2022-01-22T07:57:58.000Z

sdks/python/test/test_PurgeResponse.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 PurgeResponse.clsPurgeResponse import PurgeResponse # noqa: E501 from appcenter_sdk.rest import ApiException class TestPurgeResponse(unittest.TestCase): """PurgeResponse unit test stubs""" def setUp(self): pass def tearDown(self): pass def testPurgeResponse(self): """Test PurgeResponse""" # FIXME: construct object with mandatory attributes with example values # model = appcenter_sdk.models.clsPurgeResponse.PurgeResponse() # noqa: E501 pass if __name__ == '__main__': unittest.main()

f72bd93c4d17e05aa0d2db88c1b2ffb816c8ad18

py

Python

sdk/monitor/azure-monitor-query/setup.py

vincenttran-msft/azure-sdk-for-python

348b56f9f03eeb3f7b502eed51daf494ffff874d

2022-03-09T08:59:13.000Z

2022-03-09T08:59:13.000Z

sdk/monitor/azure-monitor-query/setup.py

vincenttran-msft/azure-sdk-for-python

348b56f9f03eeb3f7b502eed51daf494ffff874d

sdk/monitor/azure-monitor-query/setup.py

vincenttran-msft/azure-sdk-for-python

348b56f9f03eeb3f7b502eed51daf494ffff874d

#!/usr/bin/env python #------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. #-------------------------------------------------------------------------- import re import os.path from io import open from setuptools import find_packages, setup # Change the PACKAGE_NAME only to change folder and different name PACKAGE_NAME = "azure-monitor-query" PACKAGE_PPRINT_NAME = "Azure Monitor Query" # a-b-c => a/b/c package_folder_path = PACKAGE_NAME.replace('-', '/') # a-b-c => a.b.c namespace_name = PACKAGE_NAME.replace('-', '.') # azure v0.x is not compatible with this package # azure v0.x used to have a __version__ attribute (newer versions don't) try: import azure try: ver = azure.__version__ raise Exception( 'This package is incompatible with azure=={}. '.format(ver) + 'Uninstall it with "pip uninstall azure".' ) except AttributeError: pass except ImportError: pass # Version extraction inspired from 'requests' with open(os.path.join(package_folder_path, 'version.py') if os.path.exists(os.path.join(package_folder_path, 'version.py')) else os.path.join(package_folder_path, '_version.py'), 'r') as fd: version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1) if not version: raise RuntimeError('Cannot find version information') with open('README.md', encoding='utf-8') as f: readme = f.read() with open('CHANGELOG.md', encoding='utf-8') as f: changelog = f.read() setup( name=PACKAGE_NAME, version=version, description='Microsoft {} Client Library for Python'.format(PACKAGE_PPRINT_NAME), long_description=readme + '\n\n' + changelog, long_description_content_type='text/markdown', license='MIT License', author='Microsoft Corporation', author_email='azpysdkhelp@microsoft.com', url='https://github.com/Azure/azure-sdk-for-python', classifiers=[ "Development Status :: 5 - Production/Stable", 'Programming Language :: Python', 'Programming Language :: Python :: 3 :: Only', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'License :: OSI Approved :: MIT License', ], python_requires=">=3.6", zip_safe=False, packages=find_packages(exclude=[ 'tests', 'samples', # Exclude packages that will be covered by PEP420 or nspkg 'azure', 'azure.monitor', ]), install_requires=[ 'msrest>=0.6.19', 'azure-core<2.0.0,>=1.12.0', ] )

f72c09ac05b9052d87975715d4ccabff57f26a58

py

Python

LaserRender.py

gsboylan/meerk40t

7607b034368a428dfc5cab56629032d6074c756d

LaserRender.py

gsboylan/meerk40t

7607b034368a428dfc5cab56629032d6074c756d

LaserRender.py

gsboylan/meerk40t

7607b034368a428dfc5cab56629032d6074c756d

from math import floor import wx from PIL import Image from ZMatrix import ZMatrix from svgelements import * """ Laser Render provides GUI relevant methods of displaying the given project. """ DRAW_MODE_FILLS = 0x000001 DRAW_MODE_GUIDES = 0x000002 DRAW_MODE_GRID = 0x000004 DRAW_MODE_LASERPATH = 0x000008 DRAW_MODE_RETICLE = 0x000010 DRAW_MODE_SELECTION = 0x000020 DRAW_MODE_STROKES = 0x000040 DRAW_MODE_CACHE = 0x000080 # Set means do not cache. DRAW_MODE_REFRESH = 0x000100 DRAW_MODE_ANIMATE = 0x000200 DRAW_MODE_PATH = 0x000400 DRAW_MODE_IMAGE = 0x000800 DRAW_MODE_TEXT = 0x001000 DRAW_MODE_BACKGROUND = 0x002000 DRAW_MODE_ICONS = 0x0040000 DRAW_MODE_TREE = 0x0080000 DRAW_MODE_INVERT = 0x400000 DRAW_MODE_FLIPXY = 0x800000 def swizzlecolor(c): if c is None: return None if isinstance(c, int): c = Color(c) return c.blue << 16 | c.green << 8 | c.red class LaserRender: def __init__(self, device): self.device = device self.cache = None self.pen = wx.Pen() self.brush = wx.Brush() self.color = wx.Colour() def render(self, elements, gc, draw_mode=None, zoomscale=1): """ Render scene information. :param gc: :param draw_mode: :return: """ if draw_mode is None: draw_mode = self.device.draw_mode if draw_mode & (DRAW_MODE_TEXT | DRAW_MODE_IMAGE | DRAW_MODE_PATH) != 0: types = [] if draw_mode & DRAW_MODE_PATH == 0: types.append(Path) if draw_mode & DRAW_MODE_IMAGE == 0: types.append(SVGImage) if draw_mode & DRAW_MODE_TEXT == 0: types.append(SVGText) elements = [e for e in elements if type(e) in types] for element in elements: try: element.draw(element, gc, draw_mode, zoomscale=zoomscale) except AttributeError: if isinstance(element, Path): element.draw = self.draw_path elif isinstance(element, SVGImage): element.draw = self.draw_image elif isinstance(element, SVGText): element.draw = self.draw_text elif isinstance(element, Group): element.draw = self.draw_group else: continue element.draw(element, gc, draw_mode, zoomscale=zoomscale) def make_path(self, gc, path): p = gc.CreatePath() first_point = path.first_point if first_point is not None: p.MoveToPoint(first_point[0], first_point[1]) for e in path: if isinstance(e, Move): p.MoveToPoint(e.end[0], e.end[1]) elif isinstance(e, Line): p.AddLineToPoint(e.end[0], e.end[1]) elif isinstance(e, Close): p.CloseSubpath() elif isinstance(e, QuadraticBezier): p.AddQuadCurveToPoint(e.control[0], e.control[1], e.end[0], e.end[1]) elif isinstance(e, CubicBezier): p.AddCurveToPoint(e.control1[0], e.control1[1], e.control2[0], e.control2[1], e.end[0], e.end[1]) elif isinstance(e, Arc): for curve in e.as_cubic_curves(): p.AddCurveToPoint(curve.control1[0], curve.control1[1], curve.control2[0], curve.control2[1], curve.end[0], curve.end[1]) return p def set_pen(self, gc, stroke, width=1.0): if width < 1.0: width = 1.0 c = stroke if c is not None and c != 'none': swizzle_color = swizzlecolor(c) self.color.SetRGBA(swizzle_color | c.alpha << 24) # wx has BBGGRR self.pen.SetColour(self.color) self.pen.SetWidth(width) gc.SetPen(self.pen) else: gc.SetPen(wx.TRANSPARENT_PEN) def set_brush(self, gc, fill): c = fill if c is not None and c != 'none': swizzle_color = swizzlecolor(c) self.color.SetRGBA(swizzle_color | c.alpha << 24) # wx has BBGGRR self.brush.SetColour(self.color) gc.SetBrush(self.brush) else: gc.SetBrush(wx.TRANSPARENT_BRUSH) def set_element_pen(self, gc, element, zoomscale=1.0): try: sw = Length(element.stroke_width).value(ppi=96.0) # if sw < 3.0: # sw = 3.0 except AttributeError: sw = 1.0 if sw is None: sw = 1.0 limit = zoomscale**.5 if sw < limit: sw = limit self.set_pen(gc, element.stroke, width=sw) def set_element_brush(self, gc, element): self.set_brush(gc, element.fill) def draw_path(self, element, gc, draw_mode, zoomscale=1.0): """Default draw routine for the laser path element.""" try: matrix = element.transform except AttributeError: matrix = Matrix() if not hasattr(element, 'cache') or element.cache is None: cache = self.make_path(gc, element) element.cache = cache gc.PushState() gc.ConcatTransform(wx.GraphicsContext.CreateMatrix(gc, ZMatrix(matrix))) self.set_element_pen(gc, element, zoomscale=zoomscale) self.set_element_brush(gc, element) if draw_mode & DRAW_MODE_FILLS == 0 and element.fill is not None: gc.FillPath(element.cache) if draw_mode & DRAW_MODE_STROKES == 0 and element.stroke is not None: gc.StrokePath(element.cache) gc.PopState() def draw_text(self, element, gc, draw_mode, zoomscale=1.0): try: matrix = element.transform except AttributeError: matrix = Matrix() if hasattr(element, 'wxfont'): font = element.wxfont else: if element.font_size < 1: if element.font_size > 0: element.transform.pre_scale(element.font_size, element.font_size, element.x, element.y) element.font_size = 1 # No zero sized fonts. font = wx.Font(element.font_size, wx.SWISS, wx.NORMAL, wx.BOLD) try: f = [] if element.font_family is not None: f.append(str(element.font_family)) if element.font_face is not None: f.append(str(element.font_face)) if element.font_weight is not None: f.append(str(element.font_weight)) f.append("%d" % element.font_size) font.SetNativeFontInfoUserDesc(' '.join(f)) except: pass element.wxfont = font gc.PushState() gc.ConcatTransform(wx.GraphicsContext.CreateMatrix(gc, ZMatrix(matrix))) self.set_element_pen(gc, element, zoomscale=zoomscale) self.set_element_brush(gc, element) if element.fill is None or element.fill == 'none': gc.SetFont(font, wx.BLACK) else: gc.SetFont(font, wx.Colour(swizzlecolor(element.fill))) text = element.text x = element.x y = element.y if text is not None: w, h = element.width, element.height element.width, element.height = gc.GetTextExtent(element.text) if w != element.width and h != element.height: element.modified() if not hasattr(element, 'anchor') or element.anchor == 'start': y -= element.height elif element.anchor == 'middle': x -= (element.width / 2) y -= element.height elif element.anchor == 'end': x -= element.width y -= element.height gc.DrawText(text, x, y) gc.PopState() def draw_image(self, node, gc, draw_mode, zoomscale=1.0): try: matrix = node.transform except AttributeError: matrix = Matrix() gc.PushState() gc.ConcatTransform(wx.GraphicsContext.CreateMatrix(gc, ZMatrix(matrix))) if draw_mode & DRAW_MODE_CACHE == 0: cache = None try: cache = node.cache except AttributeError: pass if cache is None: try: max_allowed = node.max_allowed except AttributeError: max_allowed = 2048 node.c_width, node.c_height = node.image.size node.cache = self.make_thumbnail(node.image, maximum=max_allowed) gc.DrawBitmap(node.cache, 0, 0, node.c_width, node.c_height) else: node.c_width, node.c_height = node.image.size cache = self.make_thumbnail(node.image) gc.DrawBitmap(cache, 0, 0, node.c_width, node.c_height) gc.PopState() def draw_group(self, element, gc, draw_mode, zoomscale=1.0): pass def make_raster(self, elements, bounds, width=None, height=None, bitmap=False, step=1): if bounds is None: return None xmin, ymin, xmax, ymax = bounds xmax = ceil(xmax) ymax = ceil(ymax) xmin = floor(xmin) ymin = floor(ymin) image_width = int(xmax - xmin) if image_width == 0: image_width = 1 image_height = int(ymax - ymin) if image_height == 0: image_height = 1 if width is None: width = image_width if height is None: height = image_height width /= float(step) height /= float(step) width = int(width) height = int(height) bmp = wx.Bitmap(width, height, 32) dc = wx.MemoryDC() dc.SelectObject(bmp) dc.SetBackground(wx.WHITE_BRUSH) dc.Clear() matrix = Matrix() matrix.post_translate(-xmin, -ymin) scale_x = width / float(image_width) scale_y = height / float(image_height) scale = min(scale_x, scale_y) matrix.post_scale(scale) gc = wx.GraphicsContext.Create(dc) gc.SetInterpolationQuality(wx.INTERPOLATION_BEST) gc.PushState() gc.ConcatTransform(wx.GraphicsContext.CreateMatrix(gc, ZMatrix(matrix))) gc.SetBrush(wx.WHITE_BRUSH) gc.DrawRectangle(xmin - 1, ymin - 1, xmax + 1, ymax + 1) if not isinstance(elements, (list, tuple)): elements = [elements] self.render(elements, gc, draw_mode=DRAW_MODE_CACHE) gc.PopState() img = bmp.ConvertToImage() buf = img.GetData() image = Image.frombuffer("RGB", tuple(bmp.GetSize()), bytes(buf), "raw", "RGB", 0, 1) gc.Destroy() del dc if bitmap: return bmp return image def make_thumbnail(self, pil_data, maximum=None, width=None, height=None): """Resizes the given pil image into wx.Bitmap object that fits the constraints.""" image_width, image_height = pil_data.size if width is not None and height is None: height = width * image_height / float(image_width) if width is None and height is not None: width = height * image_width / float(image_height) if width is None and height is None: width = image_width height = image_height if maximum is not None and (width > maximum or height > maximum): scale_x = maximum / width scale_y = maximum / height scale = min(scale_x, scale_y) width = int(round(width * scale)) height = int(round(height * scale)) if image_width != width or image_height != height: pil_data = pil_data.copy().resize((width, height)) else: pil_data = pil_data.copy() if pil_data.mode != "RGBA": pil_data = pil_data.convert('RGBA') pil_bytes = pil_data.tobytes() return wx.Bitmap.FromBufferRGBA(width, height, pil_bytes)

f72c0ea16de779f16beca6532d9f0bc2298b0a63

py

Python

embiggen/sequences/generic_sequences/__init__.py

monarch-initiative/N2V

8ae02ca125f1d24ca158c2849f2d9bb1711920b9

2020-01-30T11:57:37.000Z

2020-05-02T00:05:49.000Z

embiggen/sequences/generic_sequences/__init__.py

monarch-initiative/N2V

8ae02ca125f1d24ca158c2849f2d9bb1711920b9

2020-01-26T00:43:51.000Z

2020-05-10T03:29:54.000Z

embiggen/sequences/generic_sequences/__init__.py

monarch-initiative/N2V

8ae02ca125f1d24ca158c2849f2d9bb1711920b9

2020-02-13T07:18:11.000Z

2020-03-19T08:03:34.000Z

"""Module providing generic sequences that are used throught Embiggen.""" from embiggen.sequences.generic_sequences.edge_prediction_sequence import EdgePredictionSequence __all__ = [ "EdgePredictionSequence" ]

f72c1952b0e4622f4b26e6cbf2935e7858d86d51

py

Python

BioNetGen-2.3.0/source_Atomizer/SBMLparser/atomizer/analyzeRDF.py

joseph-hellerstein/RuleBasedProgramming

fb88118ab764035979dc7c2bf8c89a7b484e4472

BioNetGen-2.3.0/source_Atomizer/SBMLparser/atomizer/analyzeRDF.py

joseph-hellerstein/RuleBasedProgramming

fb88118ab764035979dc7c2bf8c89a7b484e4472

BioNetGen-2.3.0/source_Atomizer/SBMLparser/atomizer/analyzeRDF.py

joseph-hellerstein/RuleBasedProgramming

fb88118ab764035979dc7c2bf8c89a7b484e4472

# -*- coding: utf-8 -*- """ Created on Fri Apr 27 14:45:24 2012 @author: proto """ ''' this method classifies reactants according to the rdf information, and gives us information on which reactants are the same, and how do they differ (compartment etc) ''' from sbml2bngl import SBML2BNGL import libsbml import collections def getAnnotations(parser,stringKey=None): annotation = parser.getSpeciesAnnotation() annotationDictionary = collections.defaultdict(set) for key,value in annotation.items(): annotationList = [] if annotation[key] != None: for element in annotation[key]: for index in range(0,element.getNumAttributes()): if not stringKey or stringKey in element.getValue(index): annotationList.append(element.getValue(index)) if annotationList == []: continue annotationDictionary[key].add(tuple(annotationList)) #annotationDictionary[frozenset(annotationList)].sort(lambda x,y: cmp(len(x), len(y))) return annotationDictionary def getSpeciesAnnotationStructure(parser): model = parser.model for species in model.getListOfSpecies(): name = species.getName() speciesId = species.getId() annotation = species.getAnnotation() lista = libsbml.CVTermList() libsbml.RDFAnnotationParser.parseRDFAnnotation(annotation,lista) for idx in range(0,lista.getSize()): for idx2 in range(0, lista.get(idx).getResources().getLength()): resource = lista.get(idx).getResources().getValue(idx2) qualifierType = lista.get(idx).getQualifierType() qualifierDescription= bioqual[lista.get(idx).getBiologicalQualifierType()] if qualifierType \ else modqual[lista.get(idx).getModelQualifierType()] #resource = resolveAnnotation(resource) def getEquivalence(species,rdf_database): ''' *species* is the species whose equivalence we will go and search This method will search through the RDF database and look if param 'species' is equal to any other element in the species database ''' for element in rdf_database: if species in rdf_database[element]: if rdf_database[element].index(species) == 0: return [] #return [x for x in rdf_database[element] if x != species] #well only return the first one by default return [rdf_database[element][0]] return [] if __name__ == "__main__": reader = libsbml.SBMLReader() #BIOMD0000000272 document = reader.readSBMLFromFile('XMLExamples/curated/BIOMD0000000219.xml') #document = reader.readSBMLFromFile('XMLExamples/simple4.xml') model = document.getModel() parser = SBML2BNGL(model) annotationDictionary = getAnnotations(parser) print annotationDictionary #print getEquivalence('SAv_EpoR',annotationDictionary) #print annotation #print rules

f72c19b9cb3d05c83471ebe6d0f7ab647fcf3c80

py

Python

saas/api/backend.py

markcstansberry/djaodjin-saas

0749dac36c3b039334fe9f115d92b3167eea03d6

saas/api/backend.py

markcstansberry/djaodjin-saas

0749dac36c3b039334fe9f115d92b3167eea03d6

2021-04-08T21:56:58.000Z

2022-02-10T13:26:56.000Z

saas/api/backend.py

markcstansberry/djaodjin-saas

0749dac36c3b039334fe9f115d92b3167eea03d6

# Copyright (c) 2019, DjaoDjin inc. # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #pylint:disable=useless-super-delegation from rest_framework import status from rest_framework.exceptions import ValidationError from rest_framework.generics import (RetrieveAPIView, RetrieveUpdateDestroyAPIView) from rest_framework.response import Response from ..backends import ProcessorError from ..docs import swagger_auto_schema from ..mixins import OrganizationMixin from .serializers import (BankSerializer, CardSerializer, CardTokenSerializer) #pylint: disable=no-init class RetrieveBankAPIView(OrganizationMixin, RetrieveAPIView): """ Retrieves a payout account Pass through that calls the processor API to retrieve some details about the deposit account associated to a provider (if that information is available through the :doc:`payment processor backend<backends>` API). This API does not trigger payment of a subscriber to a provider. Checkout of a subscription cart is done either through the :ref:`HTML page<pages_cart>` or :ref:`API end point<api_checkout>`. **Tags**: billing **Examples** .. code-block:: http GET /api/billing/cowork/bank/ HTTP/1.1 responds .. code-block:: json { "bank_name": "Stripe Test Bank", "last4": "***-htrTZ", "balance_amount": 0, "balance_unit": "usd" } """ serializer_class = BankSerializer def retrieve(self, request, *args, **kwargs): #pylint: disable=unused-argument return Response( self.organization.retrieve_bank()) class PaymentMethodDetailAPIView(OrganizationMixin, RetrieveUpdateDestroyAPIView): """ Retrieves a payment method Pass through to the processor to retrieve some details about the payment method (ex: credit card) associated to a subscriber. **Tags**: billing **Examples** .. code-block:: http GET /api/billing/cowork/card/ HTTP/1.1 responds .. code-block:: json { "last4": "1234", "exp_date": "12/2019" } """ serializer_class = CardSerializer def delete(self, request, *args, **kwargs): """ Deletes a payment method Pass through to the processor to remove the payment method (ex: credit card) associated to a subscriber. **Tags**: billing **Examples** .. code-block:: http DELETE /api/billing/cowork/card/ HTTP/1.1 """ return super(PaymentMethodDetailAPIView, self).delete( request, *args, **kwargs) @swagger_auto_schema(request_body=CardTokenSerializer) def put(self, request, *args, **kwargs): """ Updates a payment method Pass through to the processor to update some details about the payment method (ex: credit card) associated to a subscriber. **Tags**: billing **Examples** .. code-block:: http PUT /api/billing/cowork/card/ HTTP/1.1 .. code-block:: json { "token": "xyz" } responds .. code-block:: json { "last4": "1234", "exp_date": "12/2019" } """ return super(PaymentMethodDetailAPIView, self).put( request, *args, **kwargs) def destroy(self, request, *args, **kwargs): self.organization.delete_card() return Response(status=status.HTTP_204_NO_CONTENT) def retrieve(self, request, *args, **kwargs): #pylint: disable=unused-argument return Response(self.organization.retrieve_card()) def update(self, request, *args, **kwargs): partial = kwargs.pop('partial', False) serializer = CardTokenSerializer(data=request.data, partial=partial) serializer.is_valid(raise_exception=True) token = serializer.validated_data['token'] try: self.organization.update_card(token, self.request.user) except ProcessorError as err: raise ValidationError(err) return self.retrieve(request, *args, **kwargs)

f72c2077893d50552e9dcf77f984503151020b67

py

Python

Testing/Alignment.py

freder/PageBotExamples

eb4ced53a673b9376e8357afa9ea0795b022b13c

2020-06-20T22:01:23.000Z

2021-08-06T04:39:50.000Z

Testing/Alignment.py

freder/PageBotExamples

eb4ced53a673b9376e8357afa9ea0795b022b13c

2020-05-17T09:32:27.000Z

2021-03-15T19:45:52.000Z

Testing/Alignment.py

freder/PageBotExamples

eb4ced53a673b9376e8357afa9ea0795b022b13c

2021-02-25T19:07:45.000Z

2022-01-09T21:14:06.000Z

#!/usr/bin/env python3 # -*- coding: UTF-8 -*- # ----------------------------------------------------------------------------- # # P A G E B O T E X A M P L E S # # Copyright (c) 2017 Thom Janssen <https://github.com/thomgb> # www.pagebot.io # Licensed under MIT conditions # # Supporting DrawBot, www.drawbot.com # Supporting Flat, xxyxyz.org/flat # ----------------------------------------------------------------------------- # # TODO: Floating on second line does not seem to work currently from pagebot.toolbox.color import color from pagebot import getContext EXPORT_PATH = '_export/Start' # Export in _export folder that does not commit in Git. # Force to export to a few file formats: EXPORT_PATH_PDF = EXPORT_PATH + '.pdf' EXPORT_PATH_JPG = EXPORT_PATH + '.jpg' EXPORT_PATH_PNG = EXPORT_PATH + '.png' EXPORT_PATH_SVG = EXPORT_PATH + '.svg' # Document is the main instance holding all information about the document # together (pages, styles, etc.) from pagebot.document import Document from pagebot.elements import * from pagebot.conditions import * from pagebot.toolbox.color import Color W, H = 500, 400 def makeDocument(context): # Creates the publication/document that holds the pages. doc = Document(w=W, h=H, context=context) print(doc.view) print(doc.pages) doc.view.padding = 0 # Don't show cropmarks in this example. #doc.margin = doc.view.showPadding = True c1 = [Right2Right(), Float2Top(), Float2Left()] c2 = [Right2Right(), Float2Top()] c3 = [Left2Left()] c4 = [Left2Left(), Float2TopLeft()] c5 = [Right2Right(), Float2TopLeft()] c6 = [Left2Left(), Float2TopRight()] conditions = [c1]#, c2]#, c3, c4, c5, c6] page = doc[1] for c in conditions: makePage(doc, page, c) #page = page.next testCoordinates(context) rectSets = [] def makePage(doc, page, conditions): # Gets page by pageNumber, first in row (at this point there is only one in # this row). page.padding = 1 page.showPadding = True numberOfSquares = 8 ratio = 1 / numberOfSquares rects = [] for n in range(numberOfSquares): r = newRect(w=40, h=42, mr=4, mt=4, parent=page, fill=color(1 - n*ratio, 0, 0.5), conditions=conditions, margin=0) rects.append(r) rectSets.append(rects) score = doc.solve() doc.build() def testCoordinates(context): context.fill((0, 1, 0)) context.stroke(None) for rects in rectSets: i = 0 for r in rects: i +=1 x = r.getFloatSideLeft() y = r.getFloatSideTop() #print('%d %d' % (x, y)) context.circle(x, y, 2) context.text('%d' % i, (x + 5, y - 5)) context = getContext() makeDocument(context)

f72c27667d2dfd2d0ef541566592c06f430e047b

py

Python

scene/__init__.py

cloose/ray-tracer-challenge

5e9dd56fb67c5cba47172986a963fc22a8cbcaa2

scene/__init__.py

cloose/ray-tracer-challenge

5e9dd56fb67c5cba47172986a963fc22a8cbcaa2

scene/__init__.py

cloose/ray-tracer-challenge

5e9dd56fb67c5cba47172986a963fc22a8cbcaa2

from .camera import * from .obj_file import * from .obj_parser import * from .ray_tracer import * from .scene_parser import * from .world import *

f72c3198aa025287611b7e30ff0d1259ec7834b8

py

Python

cache_dependencies/tests/test_transaction.py

Tusky/cache-dependencies

6c19d0c2adfce19c3fdc53ad5704eddc6d84e106

2017-08-08T20:06:56.000Z

2018-09-19T03:16:20.000Z

cache_dependencies/tests/test_transaction.py

Tusky/cache-dependencies

6c19d0c2adfce19c3fdc53ad5704eddc6d84e106

2017-10-24T23:11:32.000Z

2017-10-24T23:11:32.000Z

cache_dependencies/tests/test_transaction.py

Tusky/cache-dependencies

6c19d0c2adfce19c3fdc53ad5704eddc6d84e106

2017-10-24T07:43:56.000Z

2021-06-17T07:03:02.000Z

import time import unittest from cache_dependencies import interfaces, transaction try: from unittest import mock except ImportError: import mock try: str = unicode # Python 2.* compatible string_types = (basestring,) integer_types = (int, long) except NameError: string_types = (str,) integer_types = (int,) class AbstractTransactionTestCase(unittest.TestCase): def setUp(self): self.current_time = mock.Mock(return_value=time.time()) self.lock = mock.Mock(spec=interfaces.IDependency) self.parent = mock.Mock(spec=interfaces.ITransaction) self.transaction = self._make_transaction(self.lock, self.parent, self.current_time) self.dependency = self._make_dependency() def _make_transaction(self, lock, parent, current_time_accessor): raise NotImplementedError @staticmethod def _make_dependency(): instance = mock.Mock(spec=interfaces.IDependency) instance.extend = mock.Mock(return_value=True) return instance def test_evaluate(self): self.transaction.evaluate(self.dependency, 1) self.lock.evaluate.assert_called_once_with(self.dependency, self.transaction, 1) def test_get_session_id(self): session1_id = self.transaction.get_session_id() session2_id = self.transaction.get_session_id() self.assertEqual(session1_id, session2_id) self.assertIsInstance(session2_id, string_types) def run(self, result=None): if self.__class__.__name__.startswith('Abstract'): return super(AbstractTransactionTestCase, self).run(result) class TransactionTestCase(AbstractTransactionTestCase): def _make_transaction(self, lock, parent, current_time_accessor): class Transaction(transaction.Transaction): _current_time = current_time_accessor return Transaction(lock) def test_parent(self): self.assertIsNone(self.transaction.parent()) def test_get_start_time(self): self.current_time.reset_mock() self.assertAlmostEqual(self.transaction.get_start_time(), self.current_time.return_value) initial_return_value = self.current_time.return_value self.current_time.return_value += 1 time.sleep(1) self.assertAlmostEqual(self.transaction.get_start_time(), initial_return_value) self.current_time.assert_not_called() def test_get_end_time(self): self.current_time.reset_mock() with self.assertRaises(RuntimeError): self.transaction.get_end_time() self.current_time.return_value += 1 self.transaction.finish() self.assertAlmostEqual(self.transaction.get_end_time(), self.current_time.return_value) initial_return_value = self.current_time.return_value self.current_time.return_value += 1 time.sleep(1) self.assertAlmostEqual(self.transaction.get_end_time(), initial_return_value) self.current_time.assert_called_once_with() def test_add_dependency_and_finish(self): dependency1 = self._make_dependency() dependency1.id = 1 dependency2 = self._make_dependency() dependency2.id = 2 dependency3 = self._make_dependency() dependency3.id = 3 self.transaction.add_dependency(dependency1, None) self.lock.acquire.assert_called_once_with(dependency1, self.transaction, None) self.lock.reset_mock() self.transaction.add_dependency(dependency2, None) self.lock.acquire.assert_called_once_with(dependency2, self.transaction, None) self.lock.reset_mock() dependency1.extend.assert_called_once_with(dependency2) dependency1.reset_mock() self.transaction.add_dependency(dependency3, 1) self.lock.acquire.assert_called_once_with(dependency3, self.transaction, 1) self.lock.reset_mock() dependency1.extend.assert_not_called() self.transaction.finish() self.assertEqual(self.lock.release.call_count, 2) args, kwargs = self.lock.release.call_args_list[-1] self.assertEqual(len(args[0].delegates), 1) self.assertEqual(args[0].delegates[0].id, 1) self.assertIs(args[1], self.transaction) self.assertIsNone(args[2]) args, kwargs = self.lock.release.call_args_list[-2] self.assertEqual(len(args[0].delegates), 1) self.assertEqual(args[0].delegates[0].id, 3) self.assertIs(args[1], self.transaction) self.assertEqual(args[2], 1) def test_bool(self): self.assertTrue(self.transaction) class SavePointTestCase(AbstractTransactionTestCase): def _make_transaction(self, lock, parent, current_time_accessor): return transaction.SavePoint(lock, parent) def test_parent(self): self.assertIs(self.transaction.parent(), self.parent) def test_get_start_time(self): self.transaction.get_start_time() self.parent.get_start_time.assert_called_once_with() def test_get_end_time(self): self.transaction.get_end_time() self.parent.get_end_time.assert_called_once_with() def test_add_dependency(self): self.transaction.add_dependency(self.dependency, 1) self.lock.acquire.assert_called_once_with(self.dependency, self.transaction, 1) self.parent.add_dependency.assert_called_once_with(self.dependency, 1) def test_bool(self): self.assertTrue(self.transaction) class DummyTransactionTestCase(AbstractTransactionTestCase): def _make_transaction(self, lock, parent, current_time_accessor): class DummyTransaction(transaction.DummyTransaction): _current_time = current_time_accessor return DummyTransaction(lock) def test_parent(self): self.assertIsNone(self.transaction.parent()) def test_get_start_time(self): self.current_time.reset_mock() self.assertAlmostEqual(self.transaction.get_start_time(), self.current_time.return_value) initial_return_value = self.current_time.return_value self.current_time.return_value += 1 time.sleep(1) self.assertAlmostEqual(self.transaction.get_start_time(), self.current_time.return_value) self.assertEqual(self.current_time.call_count, 2) def test_get_end_time(self): self.current_time.reset_mock() self.current_time.return_value += 1 self.assertAlmostEqual(self.transaction.get_end_time(), self.current_time.return_value) self.current_time.return_value += 1 time.sleep(1) self.assertAlmostEqual(self.transaction.get_end_time(), self.current_time.return_value) self.assertEqual(self.current_time.call_count, 2) def test_bool(self): self.assertFalse(self.transaction) class TransactionManagerTestCase(unittest.TestCase): def setUp(self): self.transaction = mock.Mock(spec=interfaces.ITransaction) self.lock = mock.Mock(spec=interfaces.IDependency) self.transaction_manager = transaction.TransactionManager(self.lock) def test_current_none(self): current_transaction = self.transaction_manager.current() self.assertIsInstance(current_transaction, transaction.DummyTransaction) def test_current_set_get(self): self.transaction_manager.current(self.transaction) self.assertIs(self.transaction_manager.current(), self.transaction) def test_begin(self): initial_transaction = self.transaction_manager.begin() self.assertIsInstance(initial_transaction, transaction.Transaction) save_point = self.transaction_manager.begin() self.assertIsInstance(save_point, transaction.SavePoint) self.assertIs(save_point.parent(), initial_transaction) nested_save_point = self.transaction_manager.begin() self.assertIsInstance(nested_save_point, transaction.SavePoint) self.assertIs(nested_save_point.parent(), save_point) def test_finish_delegate_transaction(self): self.transaction_manager.current(self.transaction) self.transaction_manager.finish() self.transaction.finish.assert_called_once_with() def test_finish_transaction(self): self.transaction_manager.begin() self.transaction_manager.finish() self.assertIsInstance(self.transaction_manager.current(), transaction.DummyTransaction) def test_finish_savepoint(self): initial_transaction = self.transaction_manager.begin() self.transaction_manager.begin() self.transaction_manager.finish() self.assertIs(self.transaction_manager.current(), initial_transaction) def test_flush(self): self.transaction_manager.begin() self.transaction_manager.begin() self.transaction_manager.begin() self.transaction_manager.flush() self.assertIsInstance(self.transaction_manager.current(), transaction.DummyTransaction)

f72c5ca5cbb2721d967ad9ef9dfa896f7ccce240

py

Python

tensorflow/python/estimator/canned/optimizers.py

tianyapiaozi/tensorflow

fb3ce0467766a8e91f1da0ad7ada7c24fde7a73a

2016-06-08T02:15:50.000Z

2022-03-02T05:30:36.000Z

tensorflow/python/estimator/canned/optimizers.py

tianyapiaozi/tensorflow

fb3ce0467766a8e91f1da0ad7ada7c24fde7a73a

2017-04-26T16:49:49.000Z

2019-10-15T11:39:26.000Z

tensorflow/python/estimator/canned/optimizers.py

tianyapiaozi/tensorflow

fb3ce0467766a8e91f1da0ad7ada7c24fde7a73a

2016-06-16T15:34:05.000Z

2022-03-12T13:23:11.000Z

# Copyright 2017 The TensorFlow Authors. 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. # ============================================================================== """Methods related to optimizers used in canned_estimators.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import six from tensorflow.python.training import adagrad from tensorflow.python.training import adam from tensorflow.python.training import ftrl from tensorflow.python.training import gradient_descent from tensorflow.python.training import optimizer as optimizer_lib from tensorflow.python.training import rmsprop _OPTIMIZER_CLS_NAMES = { 'Adagrad': adagrad.AdagradOptimizer, 'Adam': adam.AdamOptimizer, 'Ftrl': ftrl.FtrlOptimizer, 'RMSProp': rmsprop.RMSPropOptimizer, 'SGD': gradient_descent.GradientDescentOptimizer, } def get_optimizer_instance(opt, learning_rate=None): """Returns an optimizer instance. Supports the following types for the given `opt`: * An `Optimizer` instance: Returns the given `opt`. * A string: Creates an `Optimizer` subclass with the given `learning_rate`. Supported strings: * 'Adagrad': Returns an `AdagradOptimizer`. * 'Adam': Returns an `AdamOptimizer`. * 'Ftrl': Returns an `FtrlOptimizer`. * 'RMSProp': Returns an `RMSPropOptimizer`. * 'SGD': Returns a `GradientDescentOptimizer`. Args: opt: An `Optimizer` instance, or string, as discussed above. learning_rate: A float. Only used if `opt` is a string. Returns: An `Optimizer` instance. Raises: ValueError: If `opt` is an unsupported string. ValueError: If `opt` is a supported string but `learning_rate` was not specified. ValueError: If `opt` is none of the above types. """ if isinstance(opt, six.string_types): if opt in six.iterkeys(_OPTIMIZER_CLS_NAMES): if not learning_rate: raise ValueError('learning_rate must be specified when opt is string.') return _OPTIMIZER_CLS_NAMES[opt](learning_rate=learning_rate) raise ValueError( 'Unsupported optimizer name: {}. Supported names are: {}'.format( opt, tuple(sorted(six.iterkeys(_OPTIMIZER_CLS_NAMES))))) if not isinstance(opt, optimizer_lib.Optimizer): raise ValueError( 'The given object is not an Optimizer instance. Given: {}'.format(opt)) return opt

f72c705b69032d729b976d015ba6742b4d314c78

py

Python

src/olympia/files/tests/test_file_viewer.py

shashwatsingh/addons-server

8fce98901104349055a828b5a47865f5e8f4120b

src/olympia/files/tests/test_file_viewer.py

shashwatsingh/addons-server

8fce98901104349055a828b5a47865f5e8f4120b

src/olympia/files/tests/test_file_viewer.py

shashwatsingh/addons-server

8fce98901104349055a828b5a47865f5e8f4120b

# -*- coding: utf-8 -*- import mimetypes import os import shutil import zipfile from django import forms from django.conf import settings from django.core.cache import cache from django.core.files.storage import default_storage as storage import pytest from freezegun import freeze_time from unittest.mock import Mock, patch from olympia import amo from olympia.amo.tests import TestCase from olympia.files.file_viewer import DiffHelper, FileViewer, extract_file from olympia.files.models import File from olympia.files.utils import SafeZip, get_all_files from olympia.files.tests.test_utils import _run_lock_holding_process root = os.path.join(settings.ROOT, 'src/olympia/files/fixtures/files') def get_file(filename): return os.path.join(root, filename) def make_file(pk, file_path, **kwargs): obj = Mock() obj.id = obj.pk = pk for k, v in kwargs.items(): setattr(obj, k, v) obj.file_path = file_path obj.current_file_path = file_path obj.__str__ = lambda x: x.pk obj.version = Mock() obj.version.version = 1 return obj class TestFileViewer(TestCase): def setUp(self): super(TestFileViewer, self).setUp() self.viewer = FileViewer(make_file(1, get_file('dictionary-test.xpi'))) def tearDown(self): self.viewer.cleanup() super(TestFileViewer, self).tearDown() def test_files_not_extracted(self): assert not self.viewer.is_extracted() def test_files_extracted(self): self.viewer.extract() assert self.viewer.is_extracted() def test_recurse_extract(self): self.viewer.src = get_file('recurse.xpi') self.viewer.extract() assert self.viewer.is_extracted() def test_recurse_contents(self): self.viewer.src = get_file('recurse.xpi') self.viewer.extract() files = self.viewer.get_files() # We do not extract nested .zip or .xpi files anymore assert list(files.keys()) == [ u'recurse', u'recurse/chrome', u'recurse/chrome/test-root.txt', u'recurse/chrome/test.jar', u'recurse/notazip.jar', u'recurse/recurse.xpi', u'recurse/somejar.jar'] def test_locked(self): self.viewer.src = get_file('dictionary-test.xpi') # Lock was successfully attained assert self.viewer.extract() lock_name = f'file-viewer-{self.viewer.file.pk}' with _run_lock_holding_process(lock_name, sleep=3): # Not extracting, the viewer is locked, lock could not be attained assert not self.viewer.extract() def test_extract_file_locked_message(self): self.viewer.src = get_file('dictionary-test.xpi') assert not self.viewer.is_extracted() lock_name = f'file-viewer-{self.viewer.file.pk}' with _run_lock_holding_process(lock_name, sleep=3): msg = extract_file(self.viewer) assert str(msg.get()).startswith(u'File viewer is locked') msg.delete() def test_cleanup(self): self.viewer.extract() self.viewer.cleanup() assert not self.viewer.is_extracted() @freeze_time('2017-01-08 02:01:00') def test_dest(self): viewer = FileViewer(make_file(1, get_file('webextension.xpi'))) assert viewer.dest == os.path.join( settings.TMP_PATH, 'file_viewer', '0108', str(self.viewer.file.pk)) def test_isbinary(self): binary = self.viewer._is_binary for f in ['foo.rdf', 'foo.xml', 'foo.js', 'foo.py' 'foo.html', 'foo.txt', 'foo.dtd', 'foo.xul', 'foo.sh', 'foo.properties', 'foo.json', 'foo.src', 'CHANGELOG']: m, encoding = mimetypes.guess_type(f) assert not binary(m, f), '%s should not be binary' % f for f in ['foo.png', 'foo.gif', 'foo.exe', 'foo.swf']: m, encoding = mimetypes.guess_type(f) assert binary(m, f), '%s should be binary' % f filename = os.path.join(settings.TMP_PATH, 'test_isbinary') for txt in ['#!/usr/bin/python', '#python', u'\0x2']: open(filename, 'w').write(txt) m, encoding = mimetypes.guess_type(filename) assert not binary(m, filename), '%s should not be binary' % txt for txt in ['MZ']: open(filename, 'w').write(txt) m, encoding = mimetypes.guess_type(filename) assert binary(m, filename), '%s should be binary' % txt os.remove(filename) def test_truncate(self): truncate = self.viewer.truncate for x, y in (['foo.rdf', 'foo.rdf'], ['somelongfilename.rdf', 'somelongfilenam...rdf'], [u'unicode삮.txt', u'unicode\uc0ae.txt'], [u'unicodesomelong삮.txt', u'unicodesomelong...txt'], ['somelongfilename.somelongextension', 'somelongfilenam...somelonge..'],): assert truncate(x) == y def test_get_files_not_extracted_runs_extraction(self): self.viewer.src = get_file('dictionary-test.xpi') assert not self.viewer.is_extracted() self.viewer.get_files() assert self.viewer.is_extracted() def test_get_files_size(self): self.viewer.extract() files = self.viewer.get_files() assert len(files) == 14 def test_get_files_directory(self): self.viewer.extract() files = self.viewer.get_files() assert not files['install.js']['directory'] assert not files['install.js']['binary'] assert files['__MACOSX']['directory'] assert not files['__MACOSX']['binary'] def test_get_files_depth(self): self.viewer.extract() files = self.viewer.get_files() assert files['dictionaries/license.txt']['depth'] == 1 def test_bom(self): dest = os.path.join(settings.TMP_PATH, 'test_bom') with open(dest, 'wb') as f: f.write('foo'.encode('utf-16')) self.viewer.select('foo') self.viewer.selected = {'full': dest, 'size': 1} assert self.viewer.read_file() == u'foo' os.remove(dest) def test_syntax(self): for filename, syntax in [('foo.rdf', 'xml'), ('foo.xul', 'xml'), ('foo.json', 'js'), ('foo.jsm', 'js'), ('foo.htm', 'html'), ('foo.bar', 'plain'), ('foo.diff', 'plain')]: assert self.viewer.get_syntax(filename) == syntax def test_file_order(self): self.viewer.extract() dest = self.viewer.dest open(os.path.join(dest, 'chrome.manifest'), 'w') subdir = os.path.join(dest, 'chrome') os.mkdir(subdir) open(os.path.join(subdir, 'foo'), 'w') cache.delete(self.viewer._cache_key()) files = list(self.viewer.get_files().keys()) rt = files.index(u'chrome') assert files[rt:rt + 3] == [u'chrome', u'chrome/foo', u'dictionaries'] @patch.object(settings, 'FILE_VIEWER_SIZE_LIMIT', 5) def test_file_size(self): self.viewer.extract() self.viewer.get_files() self.viewer.select('install.js') res = self.viewer.read_file() assert res == '' assert self.viewer.selected['msg'].startswith('File size is') @pytest.mark.needs_locales_compilation @patch.object(settings, 'FILE_VIEWER_SIZE_LIMIT', 5) def test_file_size_unicode(self): with self.activate(locale='he'): self.viewer.extract() self.viewer.get_files() self.viewer.select('install.js') res = self.viewer.read_file() assert res == '' assert ( self.viewer.selected['msg'].startswith(u'גודל הקובץ חורג')) @patch.object(settings, 'FILE_UNZIP_SIZE_LIMIT', 5) def test_contents_size(self): self.assertRaises(forms.ValidationError, self.viewer.extract) def test_default(self): self.viewer.extract() assert self.viewer.get_default(None) == 'install.rdf' def test_default_webextension(self): viewer = FileViewer(make_file(2, get_file('webextension.xpi'))) viewer.extract() assert viewer.get_default(None) == 'manifest.json' def test_default_webextension_zip(self): viewer = FileViewer(make_file(2, get_file('webextension_no_id.zip'))) viewer.extract() assert viewer.get_default(None) == 'manifest.json' def test_default_webextension_crx(self): viewer = FileViewer(make_file(2, get_file('webextension.crx'))) viewer.extract() assert viewer.get_default(None) == 'manifest.json' def test_default_package_json(self): viewer = FileViewer(make_file(3, get_file('new-format-0.0.1.xpi'))) viewer.extract() assert viewer.get_default(None) == 'package.json' def test_delete_mid_read(self): self.viewer.extract() self.viewer.select('install.js') os.remove(os.path.join(self.viewer.dest, 'install.js')) res = self.viewer.read_file() assert res == '' assert self.viewer.selected['msg'].startswith('That file no') @patch('olympia.files.file_viewer.get_sha256') def test_delete_mid_tree(self, get_sha256): get_sha256.side_effect = IOError('ow') self.viewer.extract() with self.assertRaises(IOError): self.viewer.get_files() @patch('olympia.files.file_viewer.os.fsync') def test_verify_files_doesnt_call_fsync_regularly(self, fsync): self.viewer.extract() assert not fsync.called @patch('olympia.files.file_viewer.os.fsync') def test_verify_files_calls_fsync_on_differences(self, fsync): self.viewer.extract() assert not fsync.called files_to_verify = get_all_files(self.viewer.dest) files_to_verify.pop() module_path = 'olympia.files.file_viewer.get_all_files' with patch(module_path) as get_all_files_mck: get_all_files_mck.return_value = files_to_verify with pytest.raises(ValueError): # We don't put things back into place after fsync # so a `ValueError` is raised self.viewer._verify_files(files_to_verify) assert len(fsync.call_args_list) == len(files_to_verify) + 1 class TestSearchEngineHelper(TestCase): fixtures = ['base/addon_4594_a9'] def setUp(self): super(TestSearchEngineHelper, self).setUp() self.left = File.objects.get(pk=25753) self.viewer = FileViewer(self.left) if not os.path.exists(os.path.dirname(self.viewer.src)): os.makedirs(os.path.dirname(self.viewer.src)) with storage.open(self.viewer.src, 'w') as f: f.write('some data\n') def tearDown(self): self.viewer.cleanup() super(TestSearchEngineHelper, self).tearDown() def test_is_search_engine(self): assert self.viewer.is_search_engine() def test_extract_search_engine(self): self.viewer.extract() assert os.path.exists(self.viewer.dest) def test_default(self): self.viewer.extract() assert self.viewer.get_default(None) == 'a9.xml' def test_default_no_files(self): self.viewer.extract() os.remove(os.path.join(self.viewer.dest, 'a9.xml')) assert self.viewer.get_default(None) is None class TestDiffSearchEngine(TestCase): def setUp(self): super(TestDiffSearchEngine, self).setUp() src = os.path.join(settings.ROOT, get_file('search.xml')) if not storage.exists(src): with storage.open(src, 'w') as f: f.write(open(src).read()) self.helper = DiffHelper(make_file(1, src, filename='search.xml'), make_file(2, src, filename='search.xml')) def tearDown(self): self.helper.cleanup() super(TestDiffSearchEngine, self).tearDown() @patch( 'olympia.files.file_viewer.FileViewer.is_search_engine') def test_diff_search(self, is_search_engine): is_search_engine.return_value = True self.helper.extract() shutil.copyfile(os.path.join(self.helper.left.dest, 'search.xml'), os.path.join(self.helper.right.dest, 's-20010101.xml')) assert self.helper.select('search.xml') assert len(self.helper.get_deleted_files()) == 0 class TestDiffHelper(TestCase): def setUp(self): super(TestDiffHelper, self).setUp() src = os.path.join(settings.ROOT, get_file('dictionary-test.xpi')) self.helper = DiffHelper(make_file(1, src), make_file(2, src)) def tearDown(self): self.helper.cleanup() super(TestDiffHelper, self).tearDown() def clear_cache(self): cache.delete(self.helper.left._cache_key()) cache.delete(self.helper.right._cache_key()) def test_files_not_extracted(self): assert not self.helper.is_extracted() def test_files_extracted(self): self.helper.extract() assert self.helper.is_extracted() def test_get_files(self): assert self.helper.left.get_files() == ( self.helper.get_files()) def test_diffable(self): self.helper.extract() self.helper.select('install.js') assert self.helper.is_diffable() def test_diffable_one_missing(self): self.helper.extract() os.remove(os.path.join(self.helper.right.dest, 'install.js')) self.helper.select('install.js') assert self.helper.is_diffable() def test_diffable_allow_empty(self): self.helper.extract() self.assertRaises(AssertionError, self.helper.right.read_file) assert self.helper.right.read_file(allow_empty=True) == '' def test_diffable_both_missing(self): self.helper.extract() self.helper.select('foo.js') assert not self.helper.is_diffable() def test_diffable_deleted_files(self): self.helper.extract() os.remove(os.path.join(self.helper.left.dest, 'install.js')) assert 'install.js' in self.helper.get_deleted_files() def test_diffable_one_binary_same(self): self.helper.extract() self.helper.select('install.js') self.helper.left.selected['binary'] = True assert self.helper.is_binary() def test_diffable_one_binary_diff(self): self.helper.extract() self.change(self.helper.left.dest, 'asd') self.helper.select('install.js') self.helper.left.selected['binary'] = True assert self.helper.is_binary() def test_diffable_two_binary_diff(self): self.helper.extract() self.change(self.helper.left.dest, 'asd') self.change(self.helper.right.dest, 'asd123') self.clear_cache() self.helper.select('install.js') self.helper.left.selected['binary'] = True self.helper.right.selected['binary'] = True assert self.helper.is_binary() def test_diffable_one_directory(self): self.helper.extract() self.helper.select('install.js') self.helper.left.selected['directory'] = True assert not self.helper.is_diffable() assert self.helper.left.selected['msg'].startswith('This file') def test_diffable_parent(self): self.helper.extract() self.change(self.helper.left.dest, 'asd', filename='__MACOSX/._dictionaries') self.clear_cache() files = self.helper.get_files() assert files['__MACOSX/._dictionaries']['diff'] assert files['__MACOSX']['diff'] def change(self, file, text, filename='install.js'): path = os.path.join(file, filename) with open(path, 'rb') as f: data = f.read() data += text.encode('utf-8') with open(path, 'wb') as f2: f2.write(data) class TestSafeZipFile(TestCase, amo.tests.AMOPaths): # TODO(andym): get full coverage for existing SafeZip methods, most # is covered in the file viewer tests. @patch.object(settings, 'FILE_UNZIP_SIZE_LIMIT', 5) def test_unzip_limit(self): with pytest.raises(forms.ValidationError): SafeZip(self.xpi_path('langpack-localepicker')) def test_unzip_fatal(self): with pytest.raises(zipfile.BadZipFile): SafeZip(self.xpi_path('search.xml')) def test_read(self): zip_file = SafeZip(self.xpi_path('langpack-localepicker')) assert b'locale browser de' in zip_file.read('chrome.manifest') def test_not_secure(self): zip_file = SafeZip(self.xpi_path('extension')) assert not zip_file.is_signed() def test_is_secure(self): zip_file = SafeZip(self.xpi_path('signed')) assert zip_file.is_signed() def test_is_broken(self): zip_file = SafeZip(self.xpi_path('signed')) zip_file.info_list[2].filename = 'META-INF/foo.sf' assert not zip_file.is_signed()

f72c7105b40a75a34bc96103e54bc62ef812eb03

py

Python

rapvis/rapvis_process.py

liuwell/rapvis

a69d06a31b1d7fe4510c1c90bfeee22b68a9b3b9

2020-10-25T10:23:45.000Z

2020-10-25T10:23:45.000Z

rapvis/rapvis_process.py

liuwell/rapvis

a69d06a31b1d7fe4510c1c90bfeee22b68a9b3b9

rapvis/rapvis_process.py

liuwell/rapvis

a69d06a31b1d7fe4510c1c90bfeee22b68a9b3b9

#!/usr/bin/env python3 import glob import argparse import numpy as np import subprocess import os import time import sys #from rapvis_merge import merge_profiles, merge_gene_counts #from rapvis_gene_dis import gene_dis #from rapvis_quality import rRNAratio from rapvis_general import current_time import rapvis_rRNA def process2(R1, R2, output, adapter, threads, libpath, mapper, minlen, trim5, counts, rRNA): file_name = R1.split("/")[-1].split("_")[0] outdir = os.path.join(output, file_name) ### make directory if not os.path.exists(outdir): try: os.makedirs(outdir) except Exception as e: pass prefix = os.path.join(outdir, file_name) out_R1_p = prefix + "_R1.fq.gz" out_R1_u = prefix + "_R1_unpaired.gz" out_R2_p = prefix + "_R2.fq.gz" out_R2_u = prefix + "_R2_unpaired.gz" out_log = prefix + "_trimmomatic.log" print("\n%s Processing: %s, %s" % (current_time(), R1,R2)) realpath = sys.path[0] ### trimmomatic subprocess.call("trimmomatic PE -threads %d -phred33 %s %s %s %s %s %s ILLUMINACLIP:%s/../library/adapter/%s:1:30:10:5 SLIDINGWINDOW:4:20 MINLEN:%d HEADCROP:%d 2> %s" % (threads, R1, R2, out_R1_p, out_R1_u, out_R2_p, out_R2_u, realpath, adapter, minlen, trim5, out_log), shell=True) ### Mapping by hisat2 if mapper == 'hisat2': SummaryFile = prefix + "_hisat_summary.txt" MapOut = prefix + "_hisat_sort.bam" subprocess.call("hisat2 -p %d -x %s/genome_tran -1 %s -2 %s -U %s,%s -t --dta --summary-file %s --new-summary|samtools sort -@ %d -m 10G -o %s" % (threads, libpath, out_R1_p, out_R2_p, out_R1_u, out_R2_u, SummaryFile, threads, MapOut), shell=True) ### Mapping by STAR elif mapper == 'STAR': STARprefix = prefix + "_STAR_" subprocess.call("STAR --runThreadN %d --outSAMtype BAM SortedByCoordinate --genomeDir %s --readFilesIn %s %s --readFilesCommand zcat --outFileNamePrefix %s --quantMode GeneCounts --outFilterScoreMinOverLread 0.1 --outFilterMatchNminOverLread 0.1 --outFilterMatchNmin 0 --outFilterMismatchNmax 2" % (threads, libpath, out_R1_p, out_R2_p, STARprefix), shell=True) MapOut = prefix + "_STAR_Aligned.sortedByCoord.out.bam" ## sorted bam file ### Asemble by stringtie print("%s Asemble ..." % current_time()) stringtieGTF = prefix + '_stringtie.gtf' stringtieGene = prefix + '_gene_abund.tab' subprocess.call("stringtie %s -e -G %s/annotation.gtf -p %d -o %s -A %s" % (MapOut, libpath, threads, stringtieGTF, stringtieGene), shell=True) ### Gene counts if counts: countOut = prefix + '_gene_counts.txt' subprocess.call("featureCounts -a %s/annotation.gtf -o %s %s -t exon -g gene_name -T %d -Q 30 -p" % (libpath, countOut, MapOut, threads), shell=True) ### rRNA if rRNA: rapvis_rRNA.rRNA(R1, R2, output, threads) if __name__ == '__main__': parser = argparse.ArgumentParser(description='A tool for RNAseq processing and visualization') parser.add_argument('-R1', required=True, help='the input data R1') parser.add_argument('-R2', required=True, help='the input data R2') parser.add_argument('-o', '--output', default = 'processed_data', help = 'output directory (default: processed_data)') parser.add_argument('-p', '--threads', default=5, type=int, help='number of threads (CPUs) to use (default: 5)') #parser.add_argument('-s', '--species', default='Human', choices=['Human', 'Mouse', 'Rat', 'Rabbit', 'GoldenHamster', 'Zebrafish'], type=str, help='choose reference species for mapping and annotaion (default: Human)') parser.add_argument('-lib', '--libraryPath', type=str, help='choose reference species for mapping and annotaion') parser.add_argument('-m', '--mapper', default='hisat2', choices=['hisat2', 'STAR'], type=str, help='choose the mapping program (default: hisat2)') parser.add_argument('-a', '--adapter', default='nextera', type=str, help='choose illumina adaptor (default: nextera), choices {nextera, universal, pAAAAA}') parser.add_argument('--minlen', default=35, type=int, help='discard reads shorter than LEN (default: 35)') parser.add_argument('--trim5', default=0, type=int, help='remove bases from the begining of each read (default:0)') parser.add_argument('--counts', action='store_true', help='Get gene counts') parser.add_argument('--rRNA', action='store_true', help='whether mapping to rRNA(Human)') parser.add_argument('-v', '--version', action='version', version='%(prog)s 0.0.2') args = parser.parse_args() #print("\n%s ..... Start RNAseq processing" % (current_time())) #start_time = time.time() process2(args.R1, args.R2, args.output, args.adapter, args.threads, args.libraryPath, args.mapper, args.minlen, args.trim5, args.counts, args.rRNA) ### #end_time = time.time() #run_time = round((end_time - start_time)/60, 5) #print("\n%s ..... Finished all. Used time: %s m\n" % (current_time(), run_time))

f72c9587c2b7459c937e13b276ff7e0feb632297

py

Python

detect_image.py

YunYang1994/CodeFun

36fcdbfb4ed55fbb8f8dbc6f900842cc7bb9f068

2019-06-19T03:54:40.000Z

2019-10-21T07:09:02.000Z

detect_image.py

YunYang1994/cv-notebooks

36fcdbfb4ed55fbb8f8dbc6f900842cc7bb9f068

2019-11-26T07:27:42.000Z

2020-04-02T03:35:29.000Z

detect_image.py

YunYang1994/cv-notebooks

36fcdbfb4ed55fbb8f8dbc6f900842cc7bb9f068

2019-11-27T11:07:56.000Z

2020-03-19T15:44:20.000Z

#! /usr/bin/env python # coding=utf-8 #================================================================ # Copyright (C) 2020 * Ltd. All rights reserved. # # Editor : VIM # File name : detect_image.py # Author : YunYang1994 # Created date: 2020-03-19 14:05:53 # Description : # #================================================================ import os import cv2 import time import numpy as np import tensorflow as tf from PIL import Image, ImageFont, ImageDraw from mtcnn import pnet, rnet, onet from models import IResnet from utils import detect_face, align_face, recognize_face model = IResnet(tflite_model="IResnet.tflite") font = ImageFont.truetype('weghts/HuaWenXinWei-1.ttf', 30) image = cv2.imread("/Users/yangyun/多人照片/5.jpg") image_h, image_w, _ = image.shape org_image = image.copy() image = cv2.cvtColor(image ,cv2.COLOR_BGR2RGB) total_boxes, points = detect_face(image, 20, pnet, rnet, onet, [0.6, 0.7, 0.9], 0.709) for idx, (bounding_box, keypoints) in enumerate(zip(total_boxes, points.T)): bounding_boxes = { 'box': [int(bounding_box[0]), int(bounding_box[1]), int(bounding_box[2]-bounding_box[0]), int(bounding_box[3]-bounding_box[1])], 'confidence': bounding_box[-1], 'keypoints': { 'left_eye': (int(keypoints[0]), int(keypoints[5])), 'right_eye': (int(keypoints[1]), int(keypoints[6])), 'nose': (int(keypoints[2]), int(keypoints[7])), 'mouth_left': (int(keypoints[3]), int(keypoints[8])), 'mouth_right': (int(keypoints[4]), int(keypoints[9])), } } bounding_box = bounding_boxes['box'] keypoints = bounding_boxes['keypoints'] cv2.circle(org_image,(keypoints['left_eye']), 2, (255,0,0), 3) cv2.circle(org_image,(keypoints['right_eye']), 2, (255,0,0), 3) cv2.circle(org_image,(keypoints['nose']), 2, (255,0,0), 3) cv2.circle(org_image,(keypoints['mouth_left']), 2, (255,0,0), 3) cv2.circle(org_image,(keypoints['mouth_right']),2, (255,0,0), 3) cv2.rectangle(org_image, (bounding_box[0], bounding_box[1]), (bounding_box[0]+bounding_box[2], bounding_box[1] + bounding_box[3]), (0,255,0), 2) # align face and extract it out align_image = align_face(image, keypoints) marigin = 16 xmin = max(bounding_box[0] - marigin, 0) ymin = max(bounding_box[1] - marigin, 0) xmax = min(bounding_box[0] + bounding_box[2] + marigin, image_w) ymax = min(bounding_box[1] + bounding_box[3] + marigin, image_h) crop_image = align_image[ymin:ymax, xmin:xmax, :] if crop_image is not None: t1 = time.time() embedding = model(crop_image) person = recognize_face(embedding) org_image_pil = Image.fromarray(org_image) draw = ImageDraw.Draw(org_image_pil) text_size = draw.textsize(person, font) draw.text((bounding_box[0], bounding_box[1]-16), person, fill=(0, 0, 255), font=font) org_image = np.array(org_image_pil) t2 = time.time() print("time: %.2fms" %((t2-t1)*1000)) org_image = cv2.cvtColor(org_image, cv2.COLOR_BGR2RGB) image = Image.fromarray(org_image) image.show() # image.save("test.png")

f72caa4b74837bd62d61442cc130cfd18f4a2cb9

py

Python

src/command_modules/azure-cli-find/azure/cli/command_modules/find/_help.py

v-Ajnava/azure-cli

febec631d79bfca151e84267b5b409594bad598e

src/command_modules/azure-cli-find/azure/cli/command_modules/find/_help.py

v-Ajnava/azure-cli

febec631d79bfca151e84267b5b409594bad598e

2021-03-26T00:48:20.000Z

2022-03-29T22:05:39.000Z

src/command_modules/azure-cli-find/azure/cli/command_modules/find/_help.py

v-Ajnava/azure-cli

febec631d79bfca151e84267b5b409594bad598e

2017-12-28T04:51:44.000Z

2017-12-28T04:51:44.000Z

# -------------------------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # -------------------------------------------------------------------------------------------- from azure.cli.core.help_files import helps helps['find'] = """ type: command short-summary: Find Azure CLI commands. examples: - name: Search for commands containing 'vm' or 'secret' text: > az find -q vm secret """

f72cbe35893af2f1b2c363e8fe4e587be57b909c

py

Python

InterventionsMIP/main.py

haoxiangyang89/COVID_Staged_Alert

4c2cc5ef1d38c140875380a5f10a0fe1eaf8a47a

2021-06-24T19:27:01.000Z

2021-06-24T19:27:01.000Z

InterventionsMIP/main.py

haoxiangyang89/COVID_Staged_Alert

4c2cc5ef1d38c140875380a5f10a0fe1eaf8a47a

InterventionsMIP/main.py

haoxiangyang89/COVID_Staged_Alert

4c2cc5ef1d38c140875380a5f10a0fe1eaf8a47a

2021-12-15T13:32:25.000Z

2022-02-24T13:57:07.000Z

from InterventionsMIP import project_path, instances_path import multiprocessing as mp from threshold_policy import threshold_policy_search from interventions import Intervension from epi_params import EpiSetup, ParamDistribution from utils import parse_arguments from reporting.plotting import plot_stoch_simulations from instances import load_instance if __name__ == '__main__': # Parse arguments args = parse_arguments() # Parse city and get corresponding instance instance = load_instance(args.city, setup_file_name=args.f) # TODO Read command line args for n_proc for better integration with crunch n_proc = args.n_proc # TODO: pull out n_replicas_train and n_replicas_test to a config file n_replicas_train = args.train_reps n_replicas_test = args.test_reps # Create the pool (Note: pool needs to be created only once to run on a cluster) mp_pool = mp.Pool(n_proc) if n_proc > 1 else None for sc in [0]: for co in [0.95]: for base_line_train in [0.4]: for base_line_test in [0.4]: for const in ['test']: #[10 * i for i in range(0, 21)] + [215, 1000]: policy_class = 'step' instance_name = f'local_{instance.city}_SC{sc}_CO{co}_BLTrain{base_line_train}_BLTest_{base_line_test}_{policy_class}_{const}' print('\n============================================') print(instance_name) #TODO: This list should be longe to include all possible transmission reduction values # that might come in the instance file interventions_train = [ Intervension(0, 0, 0, instance.epi, instance.N), Intervension(1, 0, 0, instance.epi, instance.N), Intervension(0, 0, base_line_train, instance.epi, instance.N), Intervension(1, 0, base_line_train, instance.epi, instance.N), Intervension(1, 0, 0.9, instance.epi, instance.N), Intervension(0, co, base_line_train, instance.epi, instance.N), Intervension(1, co, base_line_train, instance.epi, instance.N), Intervension(1, co, 0.9, instance.epi, instance.N), Intervension(1, 0, 0.95, instance.epi, instance.N), Intervension(0, 0, 0.95, instance.epi, instance.N) ] interventions_test = [ Intervension(0, 0, 0, instance.epi, instance.N), Intervension(1, 0, 0, instance.epi, instance.N), Intervension(0, 0, base_line_test, instance.epi, instance.N), Intervension(1, 0, base_line_test, instance.epi, instance.N), Intervension(1, 0, 0.9, instance.epi, instance.N), Intervension(0, co, base_line_test, instance.epi, instance.N), Intervension(1, co, base_line_test, instance.epi, instance.N), Intervension(1, co, 0.9, instance.epi, instance.N), Intervension(1, 0, 0.95, instance.epi, instance.N), Intervension(0, 0, 0.95, instance.epi, instance.N) ] sd_levels_train = {'H': 0.9, 'L': base_line_train} sd_levels_test = {'H': 0.9, 'L': base_line_test} best_policy_replicas, policy_params = threshold_policy_search(instance, interventions_train, interventions_test, sd_levels_train, sd_levels_test, cocooning=co, school_closure=sc, mp_pool=mp_pool, n_replicas_train=n_replicas_train, n_replicas_test=n_replicas_test, instance_name=instance_name, policy={ 'class': policy_class, 'vals': [120, 216, 9] }, policy_class=policy_class) n_replicas = len(best_policy_replicas) plot_stoch_simulations( instance_name, best_policy_replicas, ['sim'] * n_replicas, plot_left_axis=['IH'], plot_right_axis=[], T=instance.T, #437, hosp_beds=instance.hosp_beds, population=instance.N.sum(), interventions=interventions_test, calendar=instance.cal, policy_params=policy_params, plot_triggers=True, plot_legend=True, show=True, align_axes=True, n_replicas=5, BL=base_line_test)

f72cc73266bff2259d90cfeb4bc45a0cffcbecaf

py

Python

p22.py

kmark1625/Project-Euler

e80c4f2044fdbff93331117b8f02aa0becbb0706

p22.py

kmark1625/Project-Euler

e80c4f2044fdbff93331117b8f02aa0becbb0706

p22.py

kmark1625/Project-Euler

e80c4f2044fdbff93331117b8f02aa0becbb0706

def read_from_file(filename): txt = open(filename) string_of_names = txt.read() return string_of_names def string_of_names_to_array(string_of_names): return string_of_names.replace('"','').split(",") def get_alpha_value(string): sum = 0 for char in string: sum += (ord(char) - 64) return sum def main(): sum = 0 filename = "p022_names.txt" string_of_names = read_from_file(filename) array_of_names = string_of_names_to_array(string_of_names) array_of_names.sort() for i in range(0, len(array_of_names)): sum += (i+1) * get_alpha_value(array_of_names[i]) return sum def test_get_alpha_value(): assert get_alpha_value("COLIN") == 53 assert get_alpha_value("A") == 1 assert get_alpha_value("Z") == 26 def test(): test_get_alpha_value() if __name__ == '__main__': test() print main()

f72cea9211379eec544b1b493a257f6c5b6255c7

py

Python

api/utils/data_utils.py

wtomin/Multitask-Emotion-Recognition-with-Incomplete-Labels

e6df7ffc9b0318fdce405e40993c79785b47c785

2020-03-08T15:29:00.000Z

2022-03-05T14:57:33.000Z

api/utils/data_utils.py

wtomin/Multitask-Emotion-Recognition-with-Incomplete-Labels

e6df7ffc9b0318fdce405e40993c79785b47c785

2020-03-06T08:56:51.000Z

2022-03-27T05:07:35.000Z

api/utils/data_utils.py

wtomin/Multitask-Emotion-Recognition-with-Incomplete-Labels

e6df7ffc9b0318fdce405e40993c79785b47c785

2020-03-20T08:19:55.000Z

2022-03-16T17:40:09.000Z

from PIL import Image import numbers class RandomCrop(object): def __init__(self, size, v): if isinstance(size, numbers.Number): self.size = (int(size), int(size)) else: self.size = size self.v = v def __call__(self, img): w, h = img.size th, tw = self.size x1 = int(( w - tw)*self.v) y1 = int(( h - th)*self.v) #print("print x, y:", x1, y1) assert(img.size[0] == w and img.size[1] == h) if w == tw and h == th: out_image = img else: out_image = img.crop((x1, y1, x1 + tw, y1 + th)) #same cropping method for all images in the same group return out_image class RandomHorizontalFlip(object): """Randomly horizontally flips the given PIL.Image with a probability of 0.5 """ def __init__(self, v): self.v = v return def __call__(self, img): if self.v < 0.5: img = img.transpose(Image.FLIP_LEFT_RIGHT) #print ("horiontal flip: ",self.v) return img

f72cf7000c24d4d32e896071d41604079d19da89

py

Python

mpsci/distributions/binomial.py

WarrenWeckesser/mpsci

675f0f3b76700529558a3bae2a1b2ca09552233b

2019-03-27T17:25:41.000Z

2022-03-31T03:55:29.000Z

mpsci/distributions/binomial.py

WarrenWeckesser/mpsci

675f0f3b76700529558a3bae2a1b2ca09552233b

2019-05-09T16:09:45.000Z

2021-01-04T03:55:09.000Z

mpsci/distributions/binomial.py

WarrenWeckesser/mpsci

675f0f3b76700529558a3bae2a1b2ca09552233b

""" Binomial distribution --------------------- """ import mpmath from ..fun import logbinomial __all__ = ['pmf', 'logpmf', 'cdf', 'sf', 'mean', 'var'] def _validate_np(n, p): if p < 0 or p > 1: raise ValueError('p must be in the range [0, 1]') if n < 0: raise ValueError('n must be a nonnegative integer.') return def pmf(k, n, p): """ Probability mass function of the binomial distribution. """ _validate_np(n, p) with mpmath.extradps(5): p = mpmath.mpf(p) return (mpmath.binomial(n, k) * mpmath.power(p, k) * mpmath.power(1 - p, n - k)) def logpmf(k, n, p): """ Natural log of the probability mass function of the binomial distribution. """ _validate_np(n, p) with mpmath.extradps(5): return (logbinomial(n, k) + k*mpmath.log(p) + mpmath.fsum([n, -k])*mpmath.log1p(-p)) def cdf(k, n, p, method='incbeta'): """ Cumulative distribution function of the binomial distribution. `method` must be either "sumpmf" or "incbeta". When `method` is "sumpmf", the CDF is computed with a simple sum of the PMF values. When `method` is "incbeta", the incomplete beta function is used. This method is generally faster than the "sumpmf" method, but for large values of k or n, the incomplete beta function of mpmath might fail. """ _validate_np(n, p) if method not in ['sumpmf', 'incbeta']: raise ValueError('method must be "sum" or "incbeta"') if method == 'incbeta': with mpmath.extradps(5): p = mpmath.mpf(p) # XXX For large values of k and/or n, betainc fails. The failure # occurs in one of the hypergeometric functions. return mpmath.betainc(n - k, k + 1, x1=0, x2=1 - p, regularized=True) else: # method is "sumpmf" with mpmath.extradps(5): c = mpmath.fsum([mpmath.exp(logpmf(t, n, p)) for t in range(k + 1)]) return c def sf(k, n, p, method='incbeta'): """ Survival function of the binomial distribution. `method` must be either "sumpmf" or "incbeta". When `method` is "sumpmf", the survival function is computed with a simple sum of the PMF values. When `method` is "incbeta", the incomplete beta function is used. This method is generally faster than the "sumpmf" method, but for large values of k or n, the incomplete beta function of mpmath might fail. """ _validate_np(n, p) if method not in ['sumpmf', 'incbeta']: raise ValueError('method must be "sum" or "incbeta"') if method == 'incbeta': with mpmath.extradps(5): p = mpmath.mpf(p) # XXX For large values of k and/or n, betainc fails. The failure # occurs in one of the hypergeometric functions. return mpmath.betainc(n - k, k + 1, x1=1-p, x2=1, regularized=True) else: # method is "sumpmf" with mpmath.extradps(5): c = mpmath.fsum([mpmath.exp(logpmf(t, n, p)) for t in range(k + 1, n + 1)]) return c def mean(n, p): """ Mean of the binomial distribution. """ _validate_np(n, p) with mpmath.extradps(5): n = mpmath.mpf(n) p = mpmath.mpf(p) return n*p def var(n, p): """ Variance of the binomial distribution. """ _validate_np(n, p) with mpmath.extradps(5): n = mpmath.mpf(n) p = mpmath.mpf(p) return n * p * (1 - p)

f72cfecb9a75e28d76c6235057fe3ad2011e3f3f

py

Python

code/txburstML.py

astrophys/Python_Debugging_Examples

510b4b6966166dddc14eda3f6813700386d2324f

code/txburstML.py

astrophys/Python_Debugging_Examples

510b4b6966166dddc14eda3f6813700386d2324f

code/txburstML.py

astrophys/Python_Debugging_Examples

510b4b6966166dddc14eda3f6813700386d2324f

#!/usr/bin/python3 import argparse import pandas as pd import numpy as np import warnings warnings.filterwarnings('ignore') from joblib import delayed,Parallel import os def whichKeep(est_params): kon = np.array(est_params)[:,0] koff = np.array(est_params)[:,1] ksyn = np.array(est_params)[:,2] which_kon = ~(kon < 2*1e-3)*~(kon > 1e3 - 1) which_koff = ~(koff < 2*1e-3)*~(koff > 1e3 - 1) which_burst = ksyn/koff > 1 which_ksyn = ksyn > 1 which = which_burst*which_koff*which_kon*which_ksyn return which def MaximumLikelihood(vals, export_asymp_ci = False, fix = 0, metod = 'L-BFGS-B'): from scipy.interpolate import interp1d from scipy.optimize import minimize from scipy import special from scipy.stats import poisson,norm from scipy.special import j_roots from scipy.special import beta as beta_fun import numpy as np if len(vals) == 0: return np.array([np.nan, np.nan, np.nan]) def dBP(at, alpha, bet, lam): at.shape = (len(at), 1) np.repeat(at, 50, axis = 1) def fun(at, m): if(max(m) < 1e6): return(poisson.pmf(at,m)) else: return(norm.pdf(at,loc=m,scale=sqrt(m))) x,w = j_roots(50,alpha = bet - 1, beta = alpha - 1) gs = np.sum(w*fun(at, m = lam*(1+x)/2), axis=1) prob = 1/beta_fun(alpha, bet)*2**(-alpha-bet+1)*gs return(prob) def LogLikelihood(x, vals): kon = x[0] koff = x[1] ksyn = x[2] return(-np.sum(np.log( dBP(vals,kon,koff,ksyn) + 1e-10) ) ) x0 = MomentInference(vals) if np.isnan(x0).any() or any(x0 < 0): x0 = np.array([10,10,10]) bnds = ((1e-3,1e3),(1e-3,1e3), (1, 1e4)) vals_ = np.copy(vals) # Otherwise the structure is violated. try: ll = minimize(LogLikelihood, x0, args = (vals_), method=metod, bounds=bnds) except: return np.array([np.nan,np.nan,np.nan]) #se = ll.hess_inv.todense().diagonal() estim = ll.x return estim # moment-based inference def MomentInference(vals, export_moments=False): # code from Anton Larsson's R implementation from scipy import stats # needs imports inside function when run in ipyparallel import numpy as np m1 = float(np.mean(vals)) m2 = float(sum(vals*(vals - 1))/len(vals)) m3 = float(sum(vals*(vals - 1)*(vals - 2))/len(vals)) # sanity check on input (e.g. need at least on expression level) if sum(vals) == 0: return np.nan if m1 == 0: return np.nan if m2 == 0: return np.nan r1=m1 r2=m2/m1 r3=m3/m2 if (r1*r2-2*r1*r3 + r2*r3) == 0: return np.nan if ((r1*r2 - 2*r1*r3 + r2*r3)*(r1-2*r2+r3)) == 0: return np.nan if (r1 - 2*r2 + r3) == 0: return np.nan lambda_est = (2*r1*(r3-r2))/(r1*r2-2*r1*r3 + r2*r3) mu_est = (2*(r3-r2)*(r1-r3)*(r2-r1))/((r1*r2 - 2*r1*r3 + r2*r3)*(r1-2*r2+r3)) v_est = (2*r1*r3 - r1*r2 - r2*r3)/(r1 - 2*r2 + r3) if export_moments: return np.array([lambda_est, mu_est, v_est, r1, r2, r3]) return np.array([lambda_est, mu_est, v_est]) parser = argparse.ArgumentParser(description='Maximum likelihood inference of bursting kinetics from scRNA-seq data') parser.add_argument('file', metavar='file', type=str, nargs=1,help='.csv file with allelic-resolution transcript counts' ) parser.add_argument('--njobs', default=[50], nargs=1, type=int, help='Number of jobs for the parallelization, default 50') args = parser.parse_args() filename = args.file[0] njobs = args.njobs[0] print('Reading file ' + filename) rpkm = pd.read_csv(filename, index_col=0) print('Inferring kinetics:') params = Parallel(n_jobs=njobs, verbose = 3)(delayed(MaximumLikelihood)(np.around(rpkm[pd.notnull(rpkm)])) for i,rpkm in rpkm.iterrows()) keep = whichKeep(params) print('Inferred kinetics of {} genes out of {} total'.format(np.sum(keep), len(keep))) base = os.path.splitext(os.path.basename(filename))[0] base = base + '_ML.pkl' print('Saving result to ' + base) pd.to_pickle(pd.DataFrame([ params, list(keep)], columns=rpkm.index).T, base)

f72d0862c33d21e1bd9da9c2c2fa5d10f09f06f4

py

Python

pystratis/api/federation/tests/test_federation.py

madrazzl3/pystratis

8b78552e753ae1d12f2afb39e9a322a270fbb7b3

pystratis/api/federation/tests/test_federation.py

madrazzl3/pystratis

8b78552e753ae1d12f2afb39e9a322a270fbb7b3

pystratis/api/federation/tests/test_federation.py

madrazzl3/pystratis

8b78552e753ae1d12f2afb39e9a322a270fbb7b3

import pytest from pytest_mock import MockerFixture from pystratis.api.federation.responsemodels import * from pystratis.api.federation import Federation from pystratis.core.networks import StraxMain, CirrusMain def test_all_strax_endpoints_implemented(strax_swagger_json): paths = [key.lower() for key in strax_swagger_json['paths']] for endpoint in paths: if Federation.route + '/' in endpoint: assert endpoint in Federation.endpoints def test_all_cirrus_endpoints_implemented(cirrus_swagger_json): paths = [key.lower() for key in cirrus_swagger_json['paths']] for endpoint in paths: if Federation.route + '/' in endpoint: assert endpoint in Federation.endpoints def test_all_interfluxstrax_endpoints_implemented(interfluxstrax_swagger_json): paths = [key.lower() for key in interfluxstrax_swagger_json['paths']] for endpoint in paths: if Federation.route + '/' in endpoint: assert endpoint in Federation.endpoints def test_all_interfluxcirrus_endpoints_implemented(interfluxcirrus_swagger_json): paths = [key.lower() for key in interfluxcirrus_swagger_json['paths']] for endpoint in paths: if Federation.route + '/' in endpoint: assert endpoint in Federation.endpoints @pytest.mark.parametrize('network', [StraxMain(), CirrusMain()], ids=['StraxMain', 'CirrusMain']) def test_reconstruct(mocker: MockerFixture, network): data = "Reconstruction flag set, please restart the node." mocker.patch.object(Federation, 'put', return_value=data) federation = Federation(network=network, baseuri=mocker.MagicMock(), session=mocker.MagicMock()) response = federation.reconstruct() assert response == data # noinspection PyUnresolvedReferences federation.put.assert_called_once() @pytest.mark.parametrize('network', [StraxMain(), CirrusMain()], ids=['StraxMain', 'CirrusMain']) def test_members_current(mocker: MockerFixture, network, generate_compressed_pubkey, get_datetime): data = { "pollStartBlockHeight": None, "pollNumberOfVotesAcquired": None, "pollFinishedBlockHeight": None, "pollWillFinishInBlocks": None, "pollExecutedBlockHeight": None, "memberWillStartMiningAtBlockHeight": None, "memberWillStartEarningRewardsEstimateHeight": None, "pollType": None, "rewardEstimatePerBlock": 0.05, "pubkey": generate_compressed_pubkey, "collateralAmount": 50000, "lastActiveTime": get_datetime(5), "periodOfInactivity": "00:02:32.9200000" } mocker.patch.object(Federation, 'get', return_value=data) federation = Federation(network=network, baseuri=mocker.MagicMock(), session=mocker.MagicMock()) response = federation.members_current() assert response == FederationMemberDetailedModel(**data) # noinspection PyUnresolvedReferences federation.get.assert_called_once() @pytest.mark.parametrize('network', [StraxMain(), CirrusMain()], ids=['StraxMain', 'CirrusMain']) def test_member(mocker: MockerFixture, network, generate_compressed_pubkey, get_datetime): data = [ { "pubkey": generate_compressed_pubkey, "collateralAmount": 50000, "lastActiveTime": get_datetime(5), "periodOfInactivity": "00:02:32.9200000" }, { "pubkey": generate_compressed_pubkey, "collateralAmount": 50000, "lastActiveTime": get_datetime(5), "periodOfInactivity": "00:02:33.9200000" }, { "pubkey": generate_compressed_pubkey, "collateralAmount": 50000, "lastActiveTime": get_datetime(5), "periodOfInactivity": "00:02:34.9200000" } ] mocker.patch.object(Federation, 'get', return_value=data) federation = Federation(network=network, baseuri=mocker.MagicMock(), session=mocker.MagicMock()) response = federation.members() assert response == [FederationMemberModel(**x) for x in data] # noinspection PyUnresolvedReferences federation.get.assert_called_once()

f72d089f873a7c0b075b4dd30a15b63980100580

py

Python

tools/ami-creator/scripts/win2019_cuda11_installer.py

mseth10/incubator-mxnet-ci

36a5050b9c7bd720a4aa87d225738400083d611d

2019-08-19T17:12:52.000Z

2021-11-07T21:25:32.000Z

tools/ami-creator/scripts/win2019_cuda11_installer.py

mseth10/incubator-mxnet-ci

36a5050b9c7bd720a4aa87d225738400083d611d

2019-10-22T17:07:40.000Z

2022-02-08T23:33:27.000Z

tools/ami-creator/scripts/win2019_cuda11_installer.py

mseth10/incubator-mxnet-ci

36a5050b9c7bd720a4aa87d225738400083d611d

2019-08-25T18:44:54.000Z

2021-11-07T21:25:25.000Z

# Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. """Dependency installer for Windows""" __author__ = 'Pedro Larroy, Chance Bair, Joe Evans' __version__ = '0.4' import argparse import errno import logging import os import psutil import shutil import subprocess import urllib import stat import tempfile import zipfile from time import sleep from urllib.error import HTTPError import logging from subprocess import check_output, check_call, call import re import sys import urllib.request import contextlib import glob import ssl ssl._create_default_https_context = ssl._create_unverified_context log = logging.getLogger(__name__) DEPS = { 'openblas': 'https://windows-post-install.s3-us-west-2.amazonaws.com/OpenBLAS-windows-v0_2_19.zip', 'opencv': 'https://windows-post-install.s3-us-west-2.amazonaws.com/opencv-windows-4.1.2-vc14_vc15.zip', 'cudnn7': 'https://windows-post-install.s3-us-west-2.amazonaws.com/cudnn-10.2-windows10-x64-v7.6.5.32.zip', 'cudnn8': 'https://windows-post-install.s3-us-west-2.amazonaws.com/cudnn-11.0-windows-x64-v8.0.3.33.zip', 'perl': 'http://strawberryperl.com/download/5.30.1.1/strawberry-perl-5.30.1.1-64bit.msi', 'clang': 'https://github.com/llvm/llvm-project/releases/download/llvmorg-9.0.1/LLVM-9.0.1-win64.exe', } DEFAULT_SUBPROCESS_TIMEOUT = 3600 @contextlib.contextmanager def remember_cwd(): ''' Restore current directory when exiting context ''' curdir = os.getcwd() try: yield finally: os.chdir(curdir) def retry(target_exception, tries=4, delay_s=1, backoff=2): """Retry calling the decorated function using an exponential backoff. http://www.saltycrane.com/blog/2009/11/trying-out-retry-decorator-python/ original from: http://wiki.python.org/moin/PythonDecoratorLibrary#Retry :param target_exception: the exception to check. may be a tuple of exceptions to check :type target_exception: Exception or tuple :param tries: number of times to try (not retry) before giving up :type tries: int :param delay_s: initial delay between retries in seconds :type delay_s: int :param backoff: backoff multiplier e.g. value of 2 will double the delay each retry :type backoff: int """ import time from functools import wraps def decorated_retry(f): @wraps(f) def f_retry(*args, **kwargs): mtries, mdelay = tries, delay_s while mtries > 1: try: return f(*args, **kwargs) except target_exception as e: logging.warning("Exception: %s, Retrying in %d seconds...", str(e), mdelay) time.sleep(mdelay) mtries -= 1 mdelay *= backoff return f(*args, **kwargs) return f_retry # true decorator return decorated_retry @retry((ValueError, OSError, HTTPError), tries=5, delay_s=2, backoff=5) def download(url, dest=None, progress=False) -> str: from urllib.request import urlopen from urllib.parse import (urlparse, urlunparse) import progressbar import http.client class ProgressCB(): def __init__(self): self.pbar = None def __call__(self, block_num, block_size, total_size): if not self.pbar and total_size > 0: self.pbar = progressbar.bar.ProgressBar(max_value=total_size) downloaded = block_num * block_size if self.pbar: if downloaded < total_size: self.pbar.update(downloaded) else: self.pbar.finish() if dest and os.path.isdir(dest): local_file = os.path.split(urlparse(url).path)[1] local_path = os.path.normpath(os.path.join(dest, local_file)) else: local_path = dest with urlopen(url) as c: content_length = c.getheader('content-length') length = int(content_length) if content_length and isinstance(c, http.client.HTTPResponse) else None if length and local_path and os.path.exists(local_path) and os.stat(local_path).st_size == length: log.debug(f"download('{url}'): Already downloaded.") return local_path log.debug(f"download({url}, {local_path}): downloading {length} bytes") if local_path: with tempfile.NamedTemporaryFile(delete=False) as tmpfd: urllib.request.urlretrieve(url, filename=tmpfd.name, reporthook=ProgressCB() if progress else None) shutil.move(tmpfd.name, local_path) else: (local_path, _) = urllib.request.urlretrieve(url, reporthook=ProgressCB()) log.debug(f"download({url}, {local_path}'): done.") return local_path # Takes arguments and runs command on host. Shell is disabled by default. # TODO: Move timeout to args def run_command(*args, shell=False, timeout=DEFAULT_SUBPROCESS_TIMEOUT, **kwargs): try: logging.info("Issuing command: {}".format(args)) res = subprocess.check_output(*args, shell=shell, timeout=timeout).decode("utf-8").replace("\r\n", "\n") logging.info("Output: {}".format(res)) except subprocess.CalledProcessError as e: raise RuntimeError("command '{}' return with error (code {}): {}".format(e.cmd, e.returncode, e.output)) return res # Copies source directory recursively to destination. def copy(src, dest): try: shutil.copytree(src, dest) logging.info("Moved {} to {}".format(src, dest)) except OSError as e: # If the error was caused because the source wasn't a directory if e.errno == errno.ENOTDIR: shutil.copy(src, dest) logging.info("Moved {} to {}".format(src, dest)) else: raise RuntimeError("copy return with error: {}".format(e)) # Workaround for windows readonly attribute error def on_rm_error(func, path, exc_info): # path contains the path of the file that couldn't be removed # let's just assume that it's read-only and unlink it. os.chmod(path, stat.S_IWRITE) os.unlink(path) def reboot_system(): logging.info("Rebooting system now...") run_command("shutdown -r -t 5") exit(0) def shutdown_system(): logging.info("Shutting down system now...") # wait 20 sec so we can capture the install logs run_command("shutdown -s -t 20") exit(0) def install_vs(): if os.path.exists("C:\\Program Files (x86)\\Microsoft Visual Studio\\2019"): logging.info("MSVS already installed, skipping.") return False # Visual Studio 2019 # Components: https://docs.microsoft.com/en-us/visualstudio/install/workload-component-id-vs-community?view=vs-2019#visual-studio-core-editor-included-with-visual-studio-community-2019 logging.info("Installing Visual Studio 2019...") vs_file_path = download('https://windows-post-install.s3-us-west-2.amazonaws.com/vs_community__1246179388.1585201415.exe') run_command("PowerShell Rename-Item -Path {} -NewName \"{}.exe\"".format(vs_file_path, vs_file_path.split('\\')[-1]), shell=True) vs_file_path = vs_file_path + '.exe' logging.info("Installing VisualStudio 2019.....") ret = call(vs_file_path + ' --add Microsoft.VisualStudio.Workload.ManagedDesktop' ' --add Microsoft.VisualStudio.Workload.NetCoreTools' ' --add Microsoft.VisualStudio.Workload.NetWeb' ' --add Microsoft.VisualStudio.Workload.Node' ' --add Microsoft.VisualStudio.Workload.Office' ' --add Microsoft.VisualStudio.Component.TypeScript.2.0' ' --add Microsoft.VisualStudio.Component.TestTools.WebLoadTest' ' --add Component.GitHub.VisualStudio' ' --add Microsoft.VisualStudio.ComponentGroup.NativeDesktop.Core' ' --add Microsoft.VisualStudio.Component.Static.Analysis.Tools' ' --add Microsoft.VisualStudio.Component.VC.CMake.Project' ' --add Microsoft.VisualStudio.Component.VC.140' ' --add Microsoft.VisualStudio.Component.Windows10SDK.18362.Desktop' ' --add Microsoft.VisualStudio.Component.Windows10SDK.18362.UWP' ' --add Microsoft.VisualStudio.Component.Windows10SDK.18362.UWP.Native' ' --add Microsoft.VisualStudio.ComponentGroup.Windows10SDK.18362' ' --add Microsoft.VisualStudio.Component.Windows10SDK.16299' ' --wait' ' --passive' ' --norestart' ) if ret == 3010 or ret == 0: # 3010 is restart required logging.info("VS install successful.") else: raise RuntimeError("VS failed to install, exit status {}".format(ret)) # Workaround for --wait sometimes ignoring the subprocesses doing component installs def vs_still_installing(): return {'vs_installer.exe', 'vs_installershell.exe', 'vs_setup_bootstrapper.exe'} & set(map(lambda process: process.name(), psutil.process_iter())) timer = 0 while vs_still_installing() and timer < DEFAULT_SUBPROCESS_TIMEOUT: logging.warning("VS installers still running for %d s", timer) if timer % 60 == 0: logging.info("Waiting for Visual Studio to install for the last {} seconds".format(str(timer))) sleep(1) timer += 1 if vs_still_installing(): logging.warning("VS install still running after timeout (%d)", DEFAULT_SUBPROCESS_TIMEOUT) else: logging.info("Visual studio install complete.") return True def install_perl(): if os.path.exists("C:\\Strawberry\\perl\\bin\\perl.exe"): logging.info("Perl already installed, skipping.") return False logging.info("Installing Perl") with tempfile.TemporaryDirectory() as tmpdir: perl_file_path = download(DEPS['perl'], tmpdir) check_call(['msiexec ', '/n', '/passive', '/i', perl_file_path]) logging.info("Perl install complete") return True def install_clang(): if os.path.exists("C:\\Program Files\\LLVM"): logging.info("Clang already installed, skipping.") return False logging.info("Installing Clang") with tempfile.TemporaryDirectory() as tmpdir: clang_file_path = download(DEPS['clang'], tmpdir) run_command(clang_file_path + " /S /D=C:\\Program Files\\LLVM") logging.info("Clang install complete") return True def install_openblas(): if os.path.exists("C:\\Program Files\\OpenBLAS-windows-v0_2_19"): logging.info("OpenBLAS already installed, skipping.") return False logging.info("Installing OpenBLAS") local_file = download(DEPS['openblas']) with zipfile.ZipFile(local_file, 'r') as zip: zip.extractall("C:\\Program Files") run_command("PowerShell Set-ItemProperty -path 'hklm:\\system\\currentcontrolset\\control\\session manager\\environment' -Name OpenBLAS_HOME -Value 'C:\\Program Files\\OpenBLAS-windows-v0_2_19'") logging.info("Openblas Install complete") return True def install_mkl(): if os.path.exists("C:\\Program Files (x86)\\IntelSWTools"): logging.info("Intel MKL already installed, skipping.") return False logging.info("Installing MKL 2019.3.203...") file_path = download("http://registrationcenter-download.intel.com/akdlm/irc_nas/tec/15247/w_mkl_2019.3.203.exe") run_command("{} --silent --remove-extracted-files yes --a install -output=C:\mkl-install-log.txt -eula=accept".format(file_path)) logging.info("MKL Install complete") return True def install_opencv(): if os.path.exists("C:\\Program Files\\opencv"): logging.info("OpenCV already installed, skipping.") return False logging.info("Installing OpenCV") with tempfile.TemporaryDirectory() as tmpdir: local_file = download(DEPS['opencv']) with zipfile.ZipFile(local_file, 'r') as zip: zip.extractall(tmpdir) copy(f'{tmpdir}\\opencv\\build', r'c:\Program Files\opencv') run_command("PowerShell Set-ItemProperty -path 'hklm:\\system\\currentcontrolset\\control\\session manager\\environment' -Name OpenCV_DIR -Value 'C:\\Program Files\\opencv'") logging.info("OpenCV install complete") return True def install_cudnn7(): if os.path.exists("C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.2\\bin\\cudnn64_7.dll"): logging.info("cuDNN7 already installed, skipping.") return False # cuDNN logging.info("Installing cuDNN7") with tempfile.TemporaryDirectory() as tmpdir: local_file = download(DEPS['cudnn7']) with zipfile.ZipFile(local_file, 'r') as zip: zip.extractall(tmpdir) for f in glob.glob(tmpdir+"\\cuda\\bin\\*"): copy(f, "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.2\\bin") for f in glob.glob(tmpdir+"\\cuda\\include\\*.h"): copy(f, "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.2\\include") for f in glob.glob(tmpdir+"\\cuda\\lib\\x64\\*"): copy(f, "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.2\\lib\\x64") logging.info("cuDNN7 install complete") return True def install_cudnn8(): if os.path.exists("C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.0\\bin\\cudnn64_8.dll"): logging.info("cuDNN7 already installed, skipping.") return False # cuDNN logging.info("Installing cuDNN8") with tempfile.TemporaryDirectory() as tmpdir: local_file = download(DEPS['cudnn8']) with zipfile.ZipFile(local_file, 'r') as zip: zip.extractall(tmpdir) for f in glob.glob(tmpdir+"\\cuda\\bin\\*"): copy(f, "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.0\\bin") for f in glob.glob(tmpdir+"\\cuda\\include\\*.h"): copy(f, "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.0\\include") for f in glob.glob(tmpdir+"\\cuda\\lib\\x64\\*"): copy(f, "C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.0\\lib\\x64") logging.info("cuDNN8 install complete") return True def instance_family(): return urllib.request.urlopen('http://instance-data/latest/meta-data/instance-type').read().decode().split('.')[0] CUDA_COMPONENTS=[ 'nvcc', 'cublas', 'cublas_dev', 'cudart', 'cufft', 'cufft_dev', 'curand', 'curand_dev', 'cusolver', 'cusolver_dev', 'cusparse', 'cusparse_dev', 'npp', 'npp_dev', 'nvrtc', 'nvrtc_dev', 'nvml_dev' ] def install_cuda110(): if os.path.exists("C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v11.0\\bin"): logging.info("CUDA 11.0 already installed, skipping.") return False logging.info("Downloadinng CUDA 11.0...") cuda_file_path = download( 'http://developer.download.nvidia.com/compute/cuda/11.0.3/network_installers/cuda_11.0.3_win10_network.exe') try: check_call("PowerShell Rename-Item -Path {} -NewName \"{}.exe\"".format(cuda_file_path, cuda_file_path.split('\\')[-1]), shell=True) except subprocess.CalledProcessError as e: logging.exception("Rename file failed") cuda_file_path = cuda_file_path + '.exe' logging.info("Installing CUDA 11.0...") check_call(cuda_file_path + ' -s') #check_call(cuda_file_path + ' -s ' + " ".join([p + "_11.0" for p in CUDA_COMPONENTS])) logging.info("Done installing CUDA 11.0.") return True def install_cuda102(): if os.path.exists("C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.2\\bin"): logging.info("CUDA 10.2 already installed, skipping.") return False logging.info("Downloading CUDA 10.2...") cuda_file_path = download( 'http://developer.download.nvidia.com/compute/cuda/10.2/Prod/network_installers/cuda_10.2.89_win10_network.exe') try: check_call("PowerShell Rename-Item -Path {} -NewName \"{}.exe\"".format(cuda_file_path, cuda_file_path.split('\\')[-1]), shell=True) except subprocess.CalledProcessError as e: logging.exception("Rename file failed") cuda_file_path = cuda_file_path + '.exe' logging.info("Installing CUDA 10.2...") check_call(cuda_file_path + ' -s') #check_call(cuda_file_path + ' -s ' + " ".join([p + "_10.2" for p in CUDA_COMPONENTS])) logging.info("Downloading CUDA 10.2 patch...") patch_file_path = download( 'http://developer.download.nvidia.com/compute/cuda/10.2/Prod/patches/1/cuda_10.2.1_win10.exe') try: check_call("PowerShell Rename-Item -Path {} -NewName \"{}.exe\"".format(patch_file_path, patch_file_path.split('\\')[-1]), shell=True) except subprocess.CalledProcessError as e: logging.exception("Rename patch failed") patch_file_path = patch_file_path + '.exe' logging.info("Installing CUDA patch...") check_call(patch_file_path + ' -s ') logging.info("Done installing CUDA 10.2 and patches.") return True def schedule_aws_userdata(): logging.info("Scheduling AWS init so userdata will run on next boot...") run_command("PowerShell C:\\ProgramData\\Amazon\\EC2-Windows\\Launch\\Scripts\\InitializeInstance.ps1 -Schedule") def add_paths(): # TODO: Add python paths (python -> C:\\Python37\\python.exe, python2 -> C:\\Python27\\python.exe) logging.info("Adding Windows Kits to PATH...") current_path = run_command( "PowerShell (Get-Itemproperty -path 'hklm:\\system\\currentcontrolset\\control\\session manager\\environment' -Name Path).Path") current_path = current_path.rstrip() logging.debug("current_path: {}".format(current_path)) new_path = current_path + \ ";C:\\Program Files (x86)\\Windows Kits\\10\\bin\\10.0.16299.0\\x86;C:\\Program Files\\OpenBLAS-windows-v0_2_19\\bin;C:\\Program Files\\LLVM\\bin;C:\\Program Files\\opencv\\bin;C:\\Program Files\\opencv\\x64\\vc15\\bin" logging.debug("new_path: {}".format(new_path)) run_command("PowerShell Set-ItemProperty -path 'hklm:\\system\\currentcontrolset\\control\\session manager\\environment' -Name Path -Value '" + new_path + "'") def script_name() -> str: """:returns: script name with leading paths removed""" return os.path.split(sys.argv[0])[1] def remove_install_task(): logging.info("Removing stage2 startup task...") run_command("PowerShell Unregister-ScheduledTask -TaskName 'Stage2Install' -Confirm:$false") def main(): logging.getLogger().setLevel(os.environ.get('LOGLEVEL', logging.DEBUG)) logging.basicConfig(filename="C:\\install.log", format='{}: %(asctime)sZ %(levelname)s %(message)s'.format(script_name())) # install all necessary software and reboot after some components # for CUDA, the last version you install will be the default, based on PATH variable if install_cuda110(): reboot_system() install_cudnn8() #if install_cuda102(): # reboot_system() #install_cudnn7() if install_vs(): reboot_system() install_openblas() install_mkl() install_opencv() install_perl() install_clang() add_paths() remove_install_task() schedule_aws_userdata() shutdown_system() if __name__ == "__main__": exit(main())

f72d316388cae4d3fa92f9185ec7e2b07efe7778

py

Python

source/spktype21.py

whiskie14142/spktype21

7ed22365fe92cdb74c416d27634df96a45712953

2021-10-21T20:07:04.000Z

2021-10-21T20:07:04.000Z

source/spktype21.py

whiskie14142/spktype21

7ed22365fe92cdb74c416d27634df96a45712953

2020-05-20T05:54:34.000Z

2020-05-20T05:54:34.000Z

source/spktype21.py

whiskie14142/spktype21

7ed22365fe92cdb74c416d27634df96a45712953

# -*- coding: utf-8 -*- """A supporting module for jplephem to handle data type 21 (Version 0.1.0) This module computes position and velocity of a celestial small body, from a NASA SPICE SPK ephemeris kernel file of data type 21 (Extended Modified Difference Arrays). http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/FORTRAN/req/spk.html You can get SPK files for many solar system small bodies from HORIZONS system of NASA/JPL. See https://ssd.jpl.nasa.gov/?horizons This module reads SPK files of data type 21, one of the types of binary SPK file. At the point of Oct. 2018, HORIZONS system provides files of type 21 for binary SPK files by default. You can get type 21 binary SPK file for celestial small bodies through TELNET interface by answering back 'Binary' for 'SPK file format'. Also you can get type 21 binary SPK file from: https://ssd.jpl.nasa.gov/x/spk.html Modules required: jplephem (version 2.6 or later) numpy Usage: from spktype21 import SPKType21 kernel = SPKType21.open('path') position, velocity = kernel.compute_type21(center, target, jd) where: path - path to the SPK file center - SPKID of central body (0 for SSB, 10 for Sun, etc.) target - SPKID of target body jd - time for computation (Julian date) Exceptions: RuntimeError will be raised when: invalid data_type of SPK file, or SPK file contains too large table in EMDA record(s) ValueError will be raised when: invalid parameter(s) of compute_type21 function Author: Shushi Uetsuki (whiskie14142) This module has been developed based on jplephem and FORTRAN source of the SPICE Toolkit of NASA/JPL/NAIF. jplephem : https://pypi.org/project/jplephem/ SPICE Toolkit : http://naif.jpl.nasa.gov/naif/toolkit.html """ from numpy import array, zeros, reshape from jplephem.daf import DAF from jplephem.names import target_names T0 = 2451545.0 S_PER_DAY = 86400.0 # Included from 'spk21.inc' on the FORTRAN source 'spke21.f' MAXTRM = 25 def jd(seconds): """Convert a number of seconds since J2000 to a Julian Date. """ return T0 + seconds / S_PER_DAY class SPKType21(object): """Class for SPK kernel to handle data type 21 (Extended Modified Difference Arrays) """ def __init__(self, daf): self.daf = daf self.segments = [Segment(self.daf, *t) for t in self.daf.summaries()] ssec = lambda s : s.start_second self.segments.sort(key=ssec) # initialize arrays for spke21 self.G = zeros(MAXTRM) self.REFPOS = zeros(3) self.REFVEL = zeros(3) self.KQ = array([0, 0, 0]) self.FC = zeros(MAXTRM) self.FC[0] = 1.0 self.WC = zeros(MAXTRM - 1) self.W = zeros(MAXTRM + 2) # initialize for compute_type21 self.mda_record_exist = False self.current_segment_exist = False @classmethod def open(cls, path): """Open the file at `path` and return an SPK instance. """ return cls(DAF(open(path, 'rb'))) def close(self): """Close this SPK file.""" self.daf.file.close() def __str__(self): daf = self.daf d = lambda b: b.decode('latin-1') lines = (str(segment) for segment in self.segments) return 'File type {0} and format {1} with {2} segments:\n{3}'.format( d(daf.locidw), d(daf.locfmt), len(self.segments), '\n'.join(lines)) def comments(self): return self.daf.comments() def compute_type21(self, center, target, jd1, jd2=0.0): """Compute position and velocity of target from SPK data (data type 21). Inputs: center - SPKID of the coordinate center (0 for Solar System Barycenter, 10 for Sun, etc) target - SPKID of the target jd1, jd2 - Julian date of epoch for computation. (jd1 + jd2) will be used for computation. If you want precise definition of epoch, jd1 should be an integer or a half integer, and jd2 should be a relatively small floating point number. Returns: Position (X, Y, Z) and velocity (XD, YD, ZD) of the target at epoch. Position and velocity are provided as Numpy arrays respectively. """ eval_sec = (jd1 - T0) eval_sec = (eval_sec + jd2) * S_PER_DAY if self.mda_record_exist: if eval_sec >= self.mda_lb and eval_sec < self.mda_ub: result = self.spke21(eval_sec, self.mda_record) return result[0:3], result[3:] self.mda_record, self.mda_lb, self.mda_ub = self.get_MDA_record(eval_sec, target, center) self.mda_record_exists = True result = self.spke21(eval_sec, self.mda_record) return result[0:3], result[3:] def get_MDA_record(self, eval_sec, target, center): """Return a EMDA record for defined epoch. Inputs: eval_sec - epoch for computation, seconds from J2000 target - body ID of the target center - body ID of coordinate center Returns: EMDA record - a Numpy array of DLSIZE floating point numbers Exception: ValueError will be raised when: eval_sed is outside of SPK data target and center are not in SPK data RuntimeError will be raised when: invalid data type of SPK data """ # chech last segment can be used if self.current_segment_exist: if eval_sec >= self.current_segment.start_second \ and eval_sec < self.current_segment.end_second \ and target == self.current_segment.target \ and center == self.current_segment.center: return self.current_segment.get_MDA_record(eval_sec) # select segments with matched 'target' and 'center' matched = [] for segment in self.segments: if segment.target == target and segment.center == center: matched.append(segment) if len(matched) == 0: raise ValueError('Invalid Target and/or Center') if eval_sec < matched[0].start_second or eval_sec >= matched[-1].end_second: raise ValueError('Invalid Time to evaluate') # selet a segment based on eval_sec found = False for segment in matched: if eval_sec < segment.end_second: found = True self.current_segment = segment break if not found: self.current_segment = matched[-1] self.current_segment_exist = True # get the MDA record from selected segment if self.current_segment.data_type != 21: raise RuntimeError('Invalid data. Data Type must be 21') return self.current_segment.get_MDA_record(eval_sec) # left this module only 2018/10/12 def spke21(self, ET, RECORD): """Compute position and velocity from a Modified Difference Array record Inputs: ET: Epoch time to evaluate position and velocity (seconds since J2000) RECORD: A record of Extended Modified Difference Array Returns: STATE STATE: A numpy array which contains position and velocity """ # This method was translated from FORTRAN source code ‘spke21.f’ of SPICE # Toolkit and modified by Shushi Uetsuki. # # SPICE Toolkit for FORTRAN : http://naif.jpl.nasa.gov/naif/toolkit_FORTRAN.html # SPK Required Reading : http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/req/spk.html # # Unfortunately, I found some discrepancies between FORTRAN source code # and actual data contained in SPK files. So, I tried to compose a # method that compute positions and velocities correctly by referencing # code of spktype01. # Following comments start with #C were copied from original FORTRAN code. #C$ Abstract #C #C Evaluate a single SPK data record from a segment of type 21 #C (Extended Difference Lines). #C #C$ Disclaimer #C #C THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE #C CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. #C GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE #C PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" #C TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY #C WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A #C PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC #C SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE #C SOFTWARE AND RELATED MATERIALS, HOWEVER USED. #C #C IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA #C BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT #C LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, #C INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, #C REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE #C REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. #C #C RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF #C THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY #C CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE #C ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. #C #C$ Required_Reading #C #C SPK #C TIME #C #C$ Keywords #C #C EPHEMERIS #C #C$ Declarations STATE = zeros(6) #C$ Brief_I/O #C #C Variable I/O Description #C -------- --- -------------------------------------------------- #C ET I Evaluation epoch. #C RECORD I Data record. #C STATE O State (position and velocity). #C MAXTRM P Maximum number of terms per difference table #C component. #C #C$ Detailed_Input #C #C ET is an epoch at which a state vector is to be #C computed. The epoch is represented as seconds past #C J2000 TDB. #C #C RECORD is a data record which, when evaluated at epoch ET, #C will give the state (position and velocity) of an #C ephemeris object, relative to its center of motion, #C in an inertial reference frame. #C #C The contents of RECORD are as follows: #C #C RECORD(1): The difference table size per #C Cartesian component. Call this #C size MAXDIM; then the difference #C line (MDA) size DLSIZE is #C #C ( 4 * MAXDIM ) + 11 #C #C RECORD(2) #C ... #C RECORD(1+DLSIZE): An extended difference line. #C The contents are: #C #C Dimension Description #C --------- ---------------------------------- #C 1 Reference epoch of difference line #C MAXDIM Stepsize function vector #C 1 Reference position vector, x #C 1 Reference velocity vector, x #C 1 Reference position vector, y #C 1 Reference velocity vector, y #C 1 Reference position vector, z #C 1 Reference velocity vector, z #C MAXDIM,3 Modified divided difference #C arrays (MDAs) #C 1 Maximum integration order plus 1 #C 3 Integration order array #C #C$ Detailed_Output #C #C STATE is the state resulting from evaluation of the input #C record at ET. Units are km and km/sec. #C #C$ Parameters #C #C MAXTRM is the maximum number of terms allowed in #C each component of the difference table #C contained in the input argument RECORD. #C See the INCLUDE file spk21.inc for the value #C of MAXTRM. #C #C$ Exceptions #C #C 1) If the maximum table size of the input record exceeds #C MAXTRM, the error SPICE(DIFFLINETOOLARGE) is signaled. #C #C$ Files #C #C None. #C #C$ Particulars #C #C The exact format and structure of type 21 (difference lines) #C segments are described in the SPK Required Reading file. #C #C SPKE21 is a modified version of SPKE01. The routine has been #C generalized to support variable size difference lines. #C #C$ Examples #C #C None. #C #C$ Restrictions #C #C Unknown. #C #C$ Literature_References #C #C NAIF Document 168.0, "S- and P- Kernel (SPK) Specification and #C User's Guide" #C #C$ Author_and_Institution #C #C N.J. Bachman (JPL) #C F.T. Krogh (JPL) #C W.L. Taber (JPL) #C I.M. Underwood (JPL) #C #C$ Version #C #C- SPICELIB Version 1.0.0, 03-FEB-2014 (NJB) (FTK) (WLT) (IMU) #C #C-& # #C$ Index_Entries #C #C evaluate type_21 spk segment #C #C-& #C #C The first element of the input record is the dimension #C of the difference table MAXDIM. #C # The FORTRAN source code indicates that RECORD[0] contains MAXDIM, but actual # data record does not contain it. MAXDIM is contained in each segment. MAXDIM = self.current_segment.MAXDIM if MAXDIM > MAXTRM: mes = ('SPKE21 \nThe input record has a maximum table dimension ' + 'of {0}, while the maximum supported by this routine is {1}. ' + 'It is possible that this problem is due to your software ' + 'beeing out of date.').format(MAXDIM, MAXTRM) raise RuntimeError(mes) return STATE #C #C Unpack the contents of the MDA array. #C #C Name Dimension Description #C ------ --------- ------------------------------- #C TL 1 Reference epoch of record #C G MAXDIM Stepsize function vector #C REFPOS 3 Reference position vector #C REFVEL 3 Reference velocity vector #C DT MAXDIM,NTE Modified divided difference arrays #C KQMAX1 1 Maximum integration order plus 1 #C KQ NTE Integration order array #C #C For our purposes, NTE is always 3. #C # The FORTRAN source code indicates that RECORD[1] contains TL, but on the # actual data RECORD[0] contains it, and all addresses for following data are # shifted forward by one. self.TL = RECORD[0] self.G = RECORD[1:MAXDIM + 1] #C #C Collect the reference position and velocity. #C self.REFPOS[0] = RECORD[MAXDIM + 1] self.REFVEL[0] = RECORD[MAXDIM + 2] self.REFPOS[1] = RECORD[MAXDIM + 3] self.REFVEL[1] = RECORD[MAXDIM + 4] self.REFPOS[2] = RECORD[MAXDIM + 5] self.REFVEL[2] = RECORD[MAXDIM + 6] #C #C Initializing the difference table is one aspect of this routine #C that's a bit different from SPKE01. Here the first dimension of #C the table in the input record can be smaller than MAXTRM. So, we #C must transfer separately the portions of the table corresponding #C to each component. #C self.DT = reshape(RECORD[MAXDIM + 7:MAXDIM * 4 + 7], (MAXDIM, 3), order='F') self.KQMAX1 = int(RECORD[4 * MAXDIM + 7]) self.KQ[0] = int(RECORD[4 * MAXDIM + 8]) self.KQ[1] = int(RECORD[4 * MAXDIM + 9]) self.KQ[2] = int(RECORD[4 * MAXDIM + 10]) #C #C Next we set up for the computation of the various differences #C self.DELTA = ET - self.TL self.TP = self.DELTA self.MQ2 = self.KQMAX1 - 2 self.KS = self.KQMAX1 - 1 #C #C This is clearly collecting some kind of coefficients. #C The problem is that we have no idea what they are... #C #C The G coefficients are supposed to be some kind of step size #C vector. #C #C TP starts out as the delta t between the request time and the #C difference line's reference epoch. We then change it from DELTA #C by the components of the stepsize vector G. #C for J in range(1, self.MQ2 + 1): #C #C Make sure we're not about to attempt division by zero. #C if self.G[J-1] == 0.0: mes = ('SPKE21\nA value of zero was found at index {0} ' + 'of the step size vector.').format(J) raise RuntimeError(mes) return STATE self.FC[J] = self.TP / self.G[J-1] self.WC[J-1] = self.DELTA / self.G[J-1] self.TP = self.DELTA + self.G[J-1] #C #C Collect KQMAX1 reciprocals. #C for J in range(1, self.KQMAX1 + 1): self.W[J-1] = 1.0 / float(J) #C #C Compute the W(K) terms needed for the position interpolation #C (Note, it is assumed throughout this routine that KS, which #C starts out as KQMAX1-1 (the ``maximum integration'') #C is at least 2. #C self.JX = 0 self.KS1 = self.KS - 1 while self.KS >= 2: self.JX = self.JX + 1 for J in range(1, self.JX + 1): self.W[J+self.KS-1] = self.FC[J] * self.W[J+self.KS1-1] - self.WC[J-1] * self.W[J+self.KS-1] self.KS = self.KS1 self.KS1 = self.KS1 - 1 #C #C Perform position interpolation: (Note that KS = 1 right now. #C We don't know much more than that.) #C for I in range(1, 3 + 1): self.KQQ = self.KQ[I-1] self.SUM = 0.0 for J in range(self.KQQ, 0, -1): self.SUM = self.SUM + self.DT[J-1, I-1] * self.W[J+self.KS-1] STATE[I-1] = self.REFPOS[I-1] + self.DELTA * (self.REFVEL[I-1] + self.DELTA * self.SUM) #C #C Again we need to compute the W(K) coefficients that are #C going to be used in the velocity interpolation. #C (Note, at this point, KS = 1, KS1 = 0.) #C for J in range(1, self.JX + 1): self.W[J+self.KS-1] = self.FC[J] * self.W[J+self.KS1-1] - self.WC[J-1] * self.W[J+self.KS-1] self.KS = self.KS - 1 #C #C Perform velocity interpolation: #C for I in range(1, 3 + 1): self.KQQ = self.KQ[I-1] self.SUM = 0.0 for J in range(self.KQQ, 0, -1): self.SUM = self.SUM + self.DT[J-1, I-1] * self.W[J+self.KS-1] STATE[I+3-1] = self.REFVEL[I-1] + self.DELTA * self.SUM return STATE class Segment(object): """A single segment of a SPK file. There are several items of information about each segment that are loaded from the underlying SPK file, and made available as object attributes: segment.source - official ephemeris name, like 'DE-0430LE-0430' segment.start_second - initial epoch, as seconds from J2000 segment.end_second - final epoch, as seconds from J2000 segment.start_jd - start_second, converted to a Julian Date segment.end_jd - end_second, converted to a Julian Date segment.center - integer center identifier segment.target - integer target identifier segment.frame - integer frame identifier segment.data_type - integer data type identifier segment.start_i - index where segment starts segment.end_i - index where segment ends """ def __init__(self, daf, source, descriptor): self.daf = daf self.source = source (self.start_second, self.end_second, self.target, self.center, self.frame, self.data_type, self.start_i, self.end_i) = descriptor self.start_jd = jd(self.start_second) self.end_jd = jd(self.end_second) # 'SPK Required Reading' indicates that the penultimate element of the segment # is the difference line size (DLSIZE), but actual data contains there a MAXDIM. self.MAXDIM = int(self.daf.map_array(self.end_i - 1, self.end_i - 1)) self.DLSIZE = 4 * self.MAXDIM + 11 def __str__(self): return self.describe(verbose=False) def describe(self, verbose=True): """Return a textual description of the segment. """ center = titlecase(target_names.get(self.center, 'Unknown center')) target = titlecase(target_names.get(self.target, 'Unknown target')) text = ('{0.start_jd:.2f}..{0.end_jd:.2f} {1} ({0.center})' ' -> {2} ({0.target})' ' data_type={0.data_type}'.format(self, center, target)) if verbose: text += ('\n frame={0.frame} data_type={0.data_type} source={1}' .format(self, self.source.decode('ascii'))) return text def get_MDA_record(self, time_sec): """Return a Modified Difference Array(MDA) record for the time to evaluate with its effective time boundaries (lower and upper). Inputs: time_sec - epoch for computation, seconds from J2000 Returns: mda_record, lower_boundary, upper_boundary mda_record: A Modified Difference Array record lower_boundary: lower boundary of the record, seconds since J2000 upper_boundary: upper boundary of the record, seconds since J2000 """ # Number of records in this segment entry_count = int(self.daf.map_array(self.end_i, self.end_i)) # Number of entries in epoch directory epoch_dir_count = entry_count // 100 # serch target epoch in epoch directory to narrow serching aria if epoch_dir_count >= 1: epoch_dir = self.daf.map_array(self.end_i - epoch_dir_count - 1, self.end_i - 2) found = False for i in range(1, epoch_dir_count + 1): if epoch_dir[i-1] > time_sec: found = True break if found: serch_last_index = i * 100 serch_start_index = (i - 1) * 100 + 1 else: serch_last_index = entry_count serch_start_index = epoch_dir_count * 100 + 1 else: serch_last_index = entry_count serch_start_index = 1 # epoch_table contains epochs for all records in this segment epoch_table = self.daf.map_array(self.start_i + (entry_count * self.DLSIZE), self.start_i + (entry_count * self.DLSIZE) + entry_count - 1) # serch target epoch in epoch_table found = False for i in range(serch_start_index, serch_last_index + 1): if epoch_table[i-1] > time_sec: found = True break if not found: i = serch_last_index record_index = i upper_boundary = epoch_table[i-1] if i != 1: lower_boundary = epoch_table[i-2] else: lower_boundary = self.start_second mda_record = self.daf.map_array(self.start_i + ((record_index - 1) * self.DLSIZE), self.start_i + (record_index * self.DLSIZE) - 1) # mda_record : one record of MDA # lower_boundary : lower boundary of epoch in this MDA record # upper_boundary : upper boundary of epoch in this MDA record return mda_record, lower_boundary, upper_boundary def titlecase(name): """Title-case target `name` if it looks safe to do so. """ return name if name.startswith(('1', 'C/', 'DSS-')) else name.title()

f72d35520a9df35cca1aca5514b7eef3d130635f

py

Python

tests/test_dipdup/models.py

spruceid/dipdup-py

adc904196cfd66563938feec0f0afcc5f3df03e3

tests/test_dipdup/models.py

spruceid/dipdup-py

adc904196cfd66563938feec0f0afcc5f3df03e3

tests/test_dipdup/models.py

spruceid/dipdup-py

adc904196cfd66563938feec0f0afcc5f3df03e3

# generated by datamodel-codegen: # filename: storage.json from __future__ import annotations from typing import Dict, List, Optional from pydantic import BaseModel, Extra class ResourceMap(BaseModel): class Config: extra = Extra.forbid id: str rate: str class ResourceCollectorStorage(BaseModel): class Config: extra = Extra.forbid administrator: str current_user: Optional[str] default_start_time: str generation_rate: str managers: List[str] metadata: Dict[str, str] nft_registry: str paused: bool resource_map: Dict[str, ResourceMap] resource_registry: str tezotop_collection: Dict[str, str] # 'resource_map': { # 'type': 'object', # 'propertyNames': {'type': 'string', '$comment': 'string'}, # 'additionalProperties': { # 'type': 'object', # 'properties': {'id': {'type': 'string', '$comment': 'nat'}, 'rate': {'type': 'string', '$comment': 'nat'}}, # 'required': ['id', 'rate'], # 'additionalProperties': False, # '$comment': 'pair', # }, # '$comment': 'map', # },

f72d627417aaa695ea5bcada408ff82f6f850efa

py

Python

trajectory_generator.py

keshaviyengar/rl-baselines-zoo

6e39f5c7c6c2d30873297308ed064551bffaa52d

trajectory_generator.py

keshaviyengar/rl-baselines-zoo

6e39f5c7c6c2d30873297308ed064551bffaa52d

trajectory_generator.py

keshaviyengar/rl-baselines-zoo

6e39f5c7c6c2d30873297308ed064551bffaa52d

import rospy from geometry_msgs.msg import Pose, Point from std_msgs.msg import Bool import numpy as np import os # This script creates a square trajectory for a robot to follow. # Will output errors as well. class CircleTrajectory(object): def __init__(self, x_offset, y_offset, z_height, radius, theta_step): self.trajectory_pub = rospy.Publisher("desired_goal", Pose, queue_size=10) self.trajectory_finish_pub = rospy.Publisher("trajectory_finish", Bool, queue_size=10) self._current_pose = Pose() # Create a timer to update the desired trajectory self.trajectory_timer = rospy.Timer(rospy.Duration(0.01), self._trajectory_callback) self.traj_finish = False # For now set initial current pose as 0 self._desired_pose = Pose() self.x_offset = x_offset self.y_offset = y_offset self.radius = radius self.thetas = np.arange(0, 2 * np.pi, np.deg2rad(theta_step)) self.thetas_counter = 0 self._desired_pose.position.x = self.x_offset + self.radius * np.cos(self.thetas[self.thetas_counter]) self._desired_pose.position.y = self.y_offset + self.radius * np.sin(self.thetas[self.thetas_counter]) self._desired_pose.position.z = z_height self._desired_pose.orientation.x = 0 self._desired_pose.orientation.y = 0 self._desired_pose.orientation.z = 0 self._desired_pose.orientation.w = 1 self.speed = 1 def _trajectory_callback(self, event): self.thetas_counter += 1 if self.thetas_counter == self.thetas.size - 1: self.traj_finish = True print("Trajectory is complete.") self.trajectory_finish_pub.publish(True) self.trajectory_timer.shutdown() if not self.traj_finish: self._desired_pose.position.x = self.x_offset + self.radius * np.cos(self.thetas[self.thetas_counter]) self._desired_pose.position.y = self.y_offset + self.radius * np.sin(self.thetas[self.thetas_counter]) # Publish new pose self.trajectory_pub.publish(self._desired_pose) class TriangleTrajectory(object): def __init__(self, point_a, point_b, point_c, z_height): self.trajectory_pub = rospy.Publisher("desired_goal", Pose, queue_size=10) self.trajectory_finish_pub = rospy.Publisher("trajectory_finish", Bool, queue_size=10) self._current_pose = Pose() # Second timer for how long to move in axis before moving to next # self.change_direction_timer = rospy.Timer(rospy.Duration(5.0), self._change_direction) # Specify three points to reach to create the triangle self.points = np.array([point_a, point_b, point_c]) self._turn_count = 0 self.del_vector = [(self.points[1][0] - self.points[0][0]), (self.points[1][1] - self.points[0][1])] self._done_trajectory = False self._desired_pose = Pose() self._desired_pose.position.x = point_a[0] self._desired_pose.position.y = point_a[1] self._desired_pose.position.z = z_height self._desired_pose.orientation.x = 0 self._desired_pose.orientation.y = 0 self._desired_pose.orientation.z = 0 self._desired_pose.orientation.w = 1 # Publish initial point and sleep to initialize for _ in range(10): self.trajectory_pub.publish(self._desired_pose) rospy.sleep(0.1) self.prev_time = rospy.get_time() self.traj_finish = False # Create a timer to update the desired trajectory self.trajectory_timer = rospy.Timer(rospy.Duration(0.01), self._trajectory_callback) # This callback changes the direction by 90 degrees, to make the square. def _change_direction(self): if self._turn_count == 0: if np.linalg.norm(self.points[self._turn_count + 1] - np.array( [self._desired_pose.position.x, self._desired_pose.position.y])) < 0.5: self._turn_count += 1 self.del_vector = [(self.points[1][0] - self.points[0][0]), (self.points[1][1] - self.points[0][1])] if self._turn_count == 1: if np.linalg.norm(self.points[self._turn_count + 1] - np.array( [self._desired_pose.position.x, self._desired_pose.position.y])) < 0.5: self._turn_count += 1 self.del_vector = [(self.points[2][0] - self.points[1][0]), (self.points[2][1] - self.points[1][1])] if self._turn_count == 2: if np.linalg.norm(self.points[0] - np.array( [self._desired_pose.position.x, self._desired_pose.position.y])) < 0.5: self._turn_count += 1 self.del_vector = [(self.points[0][0] - self.points[2][0]), (self.points[0][1] - self.points[2][1])] if self._turn_count == 3: print("Trajectory is complete.") self.traj_finish = True self.trajectory_finish_pub.publish(True) self.trajectory_timer.shutdown() # self.change_direction_timer.shutdown() def _trajectory_callback(self, event): # Compute current difference in time from last callback if not self.traj_finish: current_time = rospy.get_time() delta_t = current_time - self.prev_time self.prev_time = current_time self._change_direction() self._desired_pose.position.x += self.del_vector[0] * delta_t self._desired_pose.position.y += self.del_vector[1] * delta_t self.trajectory_pub.publish(self._desired_pose) class SquareTrajectory2(object): def __init__(self, point_a, point_b, point_c, point_d, z_height): self.trajectory_pub = rospy.Publisher("desired_goal", Pose, queue_size=10) self.trajectory_finish_pub = rospy.Publisher("trajectory_finish", Bool, queue_size=10) self._current_pose = Pose() self.points = [point_a, point_b, point_c, point_d] self._turn_count = 0 self.del_vector = [(self.points[1][0] - self.points[0][0]), (self.points[1][1] - self.points[0][1])] # For now set initial current pose as 0 self._desired_pose = Pose() self._desired_pose.position.x = point_a[0] self._desired_pose.position.y = point_a[1] self._desired_pose.position.z = z_height self._desired_pose.orientation.x = 0 self._desired_pose.orientation.y = 0 self._desired_pose.orientation.z = 0 self._desired_pose.orientation.w = 1 # Publish initial point and sleep to initialize for _ in range(10): self.trajectory_pub.publish(self._desired_pose) rospy.sleep(0.1) self.prev_time = rospy.get_time() self.traj_finish = False # Create a timer to update the desired trajectory self.trajectory_timer = rospy.Timer(rospy.Duration(0.01), self._trajectory_callback) # This callback changes the direction by 90 degrees, to make the square. def _change_direction(self): if self._turn_count == 0: if np.linalg.norm(self.points[self._turn_count + 1] - np.array( [self._desired_pose.position.x, self._desired_pose.position.y])) < 0.5: self._turn_count += 1 self.del_vector = [(self.points[1][0] - self.points[0][0]), (self.points[1][1] - self.points[0][1])] if self._turn_count == 1: if np.linalg.norm(self.points[self._turn_count + 1] - np.array( [self._desired_pose.position.x, self._desired_pose.position.y])) < 0.5: self._turn_count += 1 self.del_vector = [(self.points[2][0] - self.points[1][0]), (self.points[2][1] - self.points[1][1])] if self._turn_count == 2: if np.linalg.norm(self.points[self._turn_count + 1] - np.array( [self._desired_pose.position.x, self._desired_pose.position.y])) < 0.5: self._turn_count += 1 self.del_vector = [(self.points[3][0] - self.points[2][0]), (self.points[3][1] - self.points[2][1])] if self._turn_count == 3: if np.linalg.norm(self.points[0] - np.array( [self._desired_pose.position.x, self._desired_pose.position.y])) < 0.5: self._turn_count += 1 self.del_vector = [(self.points[0][0] - self.points[3][0]), (self.points[0][1] - self.points[3][1])] if self._turn_count == 4: print("Trajectory is complete.") self.traj_finish = True self.trajectory_finish_pub.publish(True) self.trajectory_timer.shutdown() def _trajectory_callback(self, event): # Compute current difference in time from last callback if not self.traj_finish: current_time = rospy.get_time() delta_t = current_time - self.prev_time self.prev_time = current_time self._change_direction() self._desired_pose.position.x += self.del_vector[0] * delta_t self._desired_pose.position.y += self.del_vector[1] * delta_t self.trajectory_pub.publish(self._desired_pose) if __name__ == '__main__': rospy.init_node("trajectory_generator") experiments = [7] for exp in experiments: x_offset = 5 y_offset = 5 if exp in [1, 2, 3, 4, 5]: z_height = 100 elif exp in [6, 7, 8, 9, 10]: z_height = 100 else: z_height = 125 radius = 2.0 theta_step = 0.5 print("Circle trajectory") circle_trajectory = CircleTrajectory(x_offset, y_offset, z_height, radius, theta_step) while not circle_trajectory.traj_finish: if circle_trajectory.traj_finish: break # point_a = [20, 20] # point_b = [20, 30] # point_c = [30, 20] # point_a = [-5, 0] # point_b = [-10, -5] # point_c = [5, 0] # if exp in [1, 2, 3, 4, 5]: # z_height = 100 # elif exp in [6, 7, 8, 9, 10]: # z_height = 125 # else: # z_height = 125 # print("Triangle trajectory") # triangle_trajectory = TriangleTrajectory(point_a, point_b, point_c, z_height) # while not triangle_trajectory.traj_finish: # pass # point_a = [5, 0] # point_b = [-5, 0] # point_c = [-5, -5] # point_d = [5, -5] # if exp in [1, 2, 3, 4, 5]: # z_height = 100 # elif exp in [6, 7, 8, 9, 10]: # z_height = 125 # else: # z_height = 125 # print("Square trajectory") # square_trajectory = SquareTrajectory2(point_a, point_b, point_c, point_d, z_height) # while not square_trajectory.traj_finish: # pass

f72d78d5dc3108cc117be1ea0357004699e0b64f

py

Python

rlberry/utils/torch.py

akrouriad/rlberry

dde4e2cbafca05fdef1df07646bb6368059eeadf

rlberry/utils/torch.py

akrouriad/rlberry

dde4e2cbafca05fdef1df07646bb6368059eeadf

rlberry/utils/torch.py

akrouriad/rlberry

dde4e2cbafca05fdef1df07646bb6368059eeadf

import os import re import shutil from subprocess import check_output, run, PIPE import numpy as np import torch import logging logger = logging.getLogger(__name__) def get_gpu_memory_map(): result = check_output( ["nvidia-smi", "--query-gpu=memory.used", "--format=csv,nounits,noheader"] ) return [int(x) for x in result.split()] def least_used_device(): """Get the GPU device with most available memory.""" if not torch.cuda.is_available(): raise RuntimeError("cuda unavailable") if shutil.which("nvidia-smi") is None: raise RuntimeError( "nvidia-smi unavailable: \ cannot select device with most least memory used." ) memory_map = get_gpu_memory_map() device_id = np.argmin(memory_map) logger.info( f"Choosing GPU device: {device_id}, " f"memory used: {memory_map[device_id]}" ) return torch.device("cuda:{}".format(device_id)) def choose_device(preferred_device, default_device="cpu"): if preferred_device == "cuda:best": try: preferred_device = least_used_device() except RuntimeError: logger.info( f"Could not find least used device (nvidia-smi might be missing), use cuda:0 instead" ) if torch.cuda.is_available(): return choose_device("cuda:0") else: return choose_device("cpu") try: torch.zeros((1,), device=preferred_device) # Test availability except (RuntimeError, AssertionError) as e: logger.info( f"Preferred device {preferred_device} unavailable ({e})." f"Switching to default {default_device}" ) return default_device return preferred_device def get_memory(pid=None): if not pid: pid = os.getpid() command = "nvidia-smi" result = run( command, stdout=PIPE, stderr=PIPE, universal_newlines=True, shell=True ).stdout m = re.findall( "\| *[0-9] *" + str(pid) + " *C *.*python.*? +([0-9]+).*\|", result, re.MULTILINE, ) return [int(mem) for mem in m]

f72d7e72a009707d55813c1c29a5c3ce6628c6cf

py

Python

sciwing/engine/__init__.py

sean-dingxu/sciwing

75eca1ea43be165eab20cf8bd81bbc19cecda74c

2019-09-13T10:32:29.000Z

2022-02-14T16:52:53.000Z

sciwing/engine/__init__.py

sean-dingxu/sciwing

75eca1ea43be165eab20cf8bd81bbc19cecda74c

2019-09-03T11:06:03.000Z

2021-08-20T14:57:09.000Z

sciwing/engine/__init__.py

sean-dingxu/sciwing

75eca1ea43be165eab20cf8bd81bbc19cecda74c

2019-09-16T03:25:15.000Z

2021-05-11T10:28:25.000Z

from sciwing.engine.engine import Engine

f72d8f50dd5091fb3db1affbd4c3e936c1aff93a

py

Python

sqlalchemy_geonames/files.py

dionysio/sqlalchemy-geonames

0d2542cf53512b14415319f23ad53dc4994691a8

2015-02-24T20:20:49.000Z

2021-07-21T02:32:15.000Z

sqlalchemy_geonames/files.py

dionysio/sqlalchemy-geonames

0d2542cf53512b14415319f23ad53dc4994691a8

2016-11-13T17:00:26.000Z

2020-05-28T13:12:07.000Z

sqlalchemy_geonames/files.py

dionysio/sqlalchemy-geonames

0d2542cf53512b14415319f23ad53dc4994691a8

2015-03-28T12:23:50.000Z

2020-05-28T08:41:50.000Z

BASE_DOWNLOAD_URL = 'http://download.geonames.org/export/dump/' def full_url(filename): return BASE_DOWNLOAD_URL + filename filename_config = { 'admin1CodesASCII.txt': { 'url': full_url('admin1CodesASCII.txt'), }, 'admin2Codes.txt': { 'url': full_url('admin2Codes.txt'), }, 'allCountries.txt': { 'url': full_url('allCountries.zip'), 'unzip': True, 'is_primary': True, }, 'alternateNames.txt': { 'url': full_url('alternateNames.zip'), 'unzip': True, }, 'cities1000.txt': { 'url': full_url('cities1000.zip'), 'unzip': True, 'is_primary': True, }, 'cities15000.txt': { 'url': full_url('cities15000.zip'), 'unzip': True, 'is_primary': True, }, 'cities5000.txt': { 'url': full_url('cities5000.zip'), 'unzip': True, 'is_primary': True, }, 'countryInfo.txt': { 'url': full_url('countryInfo.txt'), }, 'featureCodes_bg.txt': { 'url': full_url('featureCodes_bg.txt'), 'language_code': 'bg', }, 'featureCodes_en.txt': { 'url': full_url('featureCodes_en.txt'), 'language_code': 'en', }, 'featureCodes_nb.txt': { 'url': full_url('featureCodes_nb.txt'), 'language_code': 'nb', }, 'featureCodes_nn.txt': { 'url': full_url('featureCodes_nn.txt'), 'language_code': 'nn', }, 'featureCodes_no.txt': { 'url': full_url('featureCodes_no.txt'), 'language_code': 'no', }, 'featureCodes_ru.txt': { 'url': full_url('featureCodes_ru.txt'), 'language_code': 'ru', }, 'featureCodes_sv.txt': { 'url': full_url('featureCodes_sv.txt'), 'language_code': 'sv', }, 'hierarchy.txt': { 'url': full_url('hierarchy.zip'), 'unzip': True, }, 'iso-languagecodes.txt': { 'url': full_url('iso-languagecodes.txt'), }, 'timeZones.txt': { 'url': full_url('timeZones.txt'), }, 'userTags.txt': { 'url': full_url('userTags.zip'), 'unzip': True, }, } # TODO: Support modification files # alternateNamesDeletes-2013-12-16.txt # alternateNamesModifications-2013-12-16.txt # deletes-2013-12-16.txt # modifications-2013-12-16.txt

f72d97d1ff332aa397f3106364df1be3656a74db

py

Python

make_prg/subcommands/update.py

leoisl/make_prg

9204cb8a60d8fae0985b4eb464c5dd99c1338d45

2021-05-07T02:04:07.000Z

2021-05-07T02:04:07.000Z

make_prg/subcommands/update.py

leoisl/make_prg

9204cb8a60d8fae0985b4eb464c5dd99c1338d45

2021-03-22T12:28:06.000Z

2021-12-17T06:46:51.000Z

make_prg/subcommands/update.py

leoisl/make_prg

9204cb8a60d8fae0985b4eb464c5dd99c1338d45

2021-06-29T04:54:22.000Z

2022-01-03T12:19:59.000Z

import multiprocessing import os import shutil from pathlib import Path from loguru import logger from make_prg import io_utils from make_prg.denovo_paths_reader import DenovoPathsDB from make_prg.prg_builder import PrgBuilderCollection, PrgBuilder, LeafNotFoundException from make_prg.utils import output_files_already_exist def register_parser(subparsers): subparser_update_prg = subparsers.add_parser( "update", usage="make_prg update", help="Update PRGs given new sequences output by pandora.", ) subparser_update_prg.add_argument( "-u", "--update_DS", action="store", type=str, required=True, help=( "Filepath to the update data structures. Should point to a file *.update_DS." ), ) subparser_update_prg.add_argument( "-d", "--denovo_paths", action="store", type=str, required=True, help=( "Filepath containing denovo sequences output by pandora. Should point to a denovo_paths.txt file." ), ) subparser_update_prg.add_argument( "-o", "--output_prefix", action="store", type=str, required=True, help="Output prefix: prefix for the output files", ) subparser_update_prg.add_argument( "-t", "--threads", action="store", type=int, default=1, help="Number of threads", ) subparser_update_prg.add_argument( "--mafft", help="Path to MAFFT executable. By default, it is assumed to be on PATH", default="mafft", ) subparser_update_prg.add_argument( "--keep_temp", action="store_true", default=False, help="Keep temp files." ) subparser_update_prg.set_defaults(func=run) return subparser_update_prg def get_stats_on_variants(stats_files): nb_of_variants_successfully_applied = 0 nb_of_variants_that_failed_to_be_applied = 0 for stat_file in stats_files: with open(stat_file) as stat_file_fh: line_split = stat_file_fh.readline().strip().split() nb_of_variants_successfully_applied_for_this_locus = int(line_split[1]) nb_of_variants_successfully_applied += ( nb_of_variants_successfully_applied_for_this_locus ) nb_of_variants_that_failed_to_be_applied_for_this_locus = int(line_split[2]) nb_of_variants_that_failed_to_be_applied += ( nb_of_variants_that_failed_to_be_applied_for_this_locus ) return nb_of_variants_successfully_applied, nb_of_variants_that_failed_to_be_applied def update( locus_name, prg_builder_pickle_filepath, variant_nodes_with_mutation, temp_dir, mafft: str, ): prg_builder_for_locus = PrgBuilder.deserialize(prg_builder_pickle_filepath) nb_of_variants_sucessfully_updated = 0 nb_of_variants_with_failed_update = 0 we_have_variants = len(variant_nodes_with_mutation) > 0 if we_have_variants: logger.debug(f"Updating {locus_name} ...") leaves_to_update = set() for variant_node_with_mutation in variant_nodes_with_mutation: try: prg_builder_tree_node = prg_builder_for_locus.get_node_given_interval( variant_node_with_mutation.key ) prg_builder_tree_node.add_seq_to_batch_update( variant_node_with_mutation.mutated_node_sequence ) leaves_to_update.add(prg_builder_tree_node) nb_of_variants_sucessfully_updated += 1 except LeafNotFoundException as exc: logger.debug(f"Failed finding leaf: {exc}") nb_of_variants_with_failed_update += 1 # update the changed leaves for leaf in leaves_to_update: leaf.batch_update(temp_dir, mafft=mafft) logger.debug( f"Updated {locus_name}: {len(variant_nodes_with_mutation)} denovo sequences added!" ) else: logger.debug(f"{locus_name} has no new variants, no update needed") # regenerate PRG locus_prefix = temp_dir / locus_name / locus_name locus_prefix_parent = locus_prefix.parent os.makedirs(locus_prefix_parent, exist_ok=True) prg = prg_builder_for_locus.build_prg() logger.info(f"Write PRG file to {locus_prefix}.prg.fa") io_utils.write_prg(str(locus_prefix), prg) with open(f"{locus_prefix}.stats", "w") as stats_filehandler: print( f"{locus_name} {nb_of_variants_sucessfully_updated} {nb_of_variants_with_failed_update}", file=stats_filehandler, ) # Note: we intentionally do not regenerate updateable data structure here because we don't want to update # PRGs on top of already updated PRGs # TODO: change this? def run(options): if output_files_already_exist(options.output_prefix): raise RuntimeError("One or more output files already exists, aborting run...") # NB: don't use logging, it causes deadlocks: https://pythonspeed.com/articles/python-multiprocessing/ logger.info("Reading update data structures...") prg_builder_collection = PrgBuilderCollection.deserialize(options.update_DS) prg_builder_collection.to_absolute_paths(Path(options.update_DS).parent) logger.info(f"Reading {options.denovo_paths}...") denovo_paths_db = DenovoPathsDB(options.denovo_paths) output_dir = Path(options.output_prefix).parent os.makedirs(output_dir, exist_ok=True) temp_path = Path(options.output_prefix + "_tmp") os.makedirs(temp_path, exist_ok=True) # update all PRGs with denovo sequences logger.debug(f"Using {options.threads} threads to update PRGs...") multithreaded_input = [] for ( locus_name, prg_builder_pickle_filepath, ) in ( prg_builder_collection.locus_name_to_pickle_files.items() ): # we do for all PRGs as those that don't have denovo variants will be generated also variant_nodes_with_mutation = ( denovo_paths_db.locus_name_to_variant_nodes_with_mutation.get( locus_name, [] ) ) multithreaded_input.append( ( locus_name, prg_builder_pickle_filepath, variant_nodes_with_mutation, temp_path, options.mafft, ) ) with multiprocessing.Pool(options.threads, maxtasksperchild=1) as pool: pool.starmap(update, multithreaded_input, chunksize=1) logger.success(f"All PRGs updated!") # concatenate output PRGs logger.info("Concatenating files from several threads into single, final file...") prg_files = [ f"{temp_path}/{locus_name}/{locus_name}.prg.fa" for locus_name in prg_builder_collection.locus_name_to_pickle_files.keys() ] io_utils.concatenate_text_files(prg_files, options.output_prefix + ".prg.fa") # sum up stats files and output stats stats_files = [ f"{temp_path}/{locus_name}/{locus_name}.stats" for locus_name in prg_builder_collection.locus_name_to_pickle_files.keys() ] ( nb_of_variants_successfully_applied, nb_of_variants_that_failed_to_be_applied, ) = get_stats_on_variants(stats_files) logger.success( f"Number of variants successfully applied: {nb_of_variants_successfully_applied}" ) logger.warning( f"Number of variants that failed to be applied: {nb_of_variants_that_failed_to_be_applied}" ) # remove temp files if needed if not options.keep_temp and temp_path.exists(): logger.debug("Removing temp files...") shutil.rmtree(temp_path) logger.success("All done!")

f72dc8316a82c5f73e59a6498145758dff2e6fa1

py

Python

python/ABC/2020-07-25_m-solutions2020/c.py

KATO-Hiro/atcoder-1

c2cbfcfd5c3d46ac9810ba330a37d437aa2839c2

python/ABC/2020-07-25_m-solutions2020/c.py

KATO-Hiro/atcoder-1

c2cbfcfd5c3d46ac9810ba330a37d437aa2839c2

python/ABC/2020-07-25_m-solutions2020/c.py

KATO-Hiro/atcoder-1

c2cbfcfd5c3d46ac9810ba330a37d437aa2839c2

import sys input = sys.stdin.readline def main(): N, K = map(int, input().split()) A = tuple(map(int, input().split())) ans = [0] * (N - K) for i in range(N - K): if A[i] < A[K + i]: ans[i] = "Yes" else: ans[i] = "No" print("\n".join(ans)) if __name__ == "__main__": main()

f72e0a3f831f9e9c61a2e9d77828ffb12d8428b1

py

Python

tensorflow/contrib/training/python/training/training.py

tianyapiaozi/tensorflow

fb3ce0467766a8e91f1da0ad7ada7c24fde7a73a

2017-05-25T16:02:15.000Z

2021-06-09T16:08:08.000Z

tensorflow/contrib/training/python/training/training.py

shrikunjsarda/tensorflow

7e8927e7af0c51ac20a63bd4eab6ff83df1a39ae

2017-04-26T16:49:49.000Z

2019-10-15T11:39:26.000Z

tensorflow/contrib/training/python/training/training.py

shrikunjsarda/tensorflow

7e8927e7af0c51ac20a63bd4eab6ff83df1a39ae

2018-09-11T02:17:17.000Z

2021-12-15T10:33:35.000Z

# Copyright 2016 The TensorFlow Authors. 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. # ============================================================================== """Contains various routines and helper functions for training models. This script contains various functions for training models. These include manipulating gradients, creating a `train_op` (an operation that computes the loss and applies the gradients) and a training loop function. The training loop allows the user to pass in the `train_op` and runs the optimization according to user-specified arguments. ************************************ * A simple working training script * ************************************ # Load data and create the model: images, labels = LoadData(...) predictions = MyModel(images) # Define the loss: tf.contrib.losses.log_loss(predictions, labels) total_loss = tf.contrib.losses.get_total_loss() # Define the optimizer: optimizer = tf.train.MomentumOptimizer(FLAGS.learning_rate, FLAGS.momentum) # Create the train_op train_op = tf.contrib.training.create_train_op(total_loss, optimizer) # Run training. tf.contrib.training.train(train_op, my_log_dir) ************************* * Creating the train_op * ************************* In order to use the `train` function, one needs a train_op: an `Operation` that (a) computes the loss, (b) applies the gradients to update the weights and (c) returns the value of the loss. tf.contrib.training.create_train_op creates such an `Operation`. This function also provides the ability to manipulate the gradients using a few arguments: # Create the train_op and clip the gradient norms: train_op = tf.contrib.training.create_train_op( total_loss, optimizer, transform_grads_fn=clip_gradient_norms_fn(3)) # Create the train_op and scale the gradients by providing a map from variable # name (or variable) to a scaling coefficient: def transform_grads_fn(grads): gradient_multipliers = { 'conv0/weights': 1.2, 'fc8/weights': 3.4, } return tf.contrib.training.multiply_gradients( grads, gradient_multipliers) train_op = tf.contrib.training.create_train_op( total_loss, optimizer, transform_grads_fn=transform_grads_fn) **************************************************************** * Performing additional (non-gradient) updates during training * **************************************************************** Many networks utilize modules, like BatchNorm, that require performing a series of non-gradient updates during training. tf.contrib.training.create_train_op allows a user to pass in a list of update_ops to call along with the gradient updates. train_op = tf.contrib.training.create_train_op( total_loss, optimizer, update_ops) By default, tf.contrib.training.create_train_op includes all update ops that are part of the `tf.GraphKeys.UPDATE_OPS` collection. Additionally, the tf.contrib.layers.batch_norm function adds the moving mean and moving variance updates to this collection. Consequently, users who want to use tf.contrib.layers.batch_norm will not need to take any additional steps in order to have the moving mean and moving variance updates be computed. However, users with additional, specialized updates can either override the default update ops or simply add additional update ops to the `tf.GraphKeys.UPDATE_OPS` collection: # Force `create_train_op` to NOT use ANY update_ops: train_op = tf.contrib.training.create_train_op( total_loss, optimizer, update_ops=[]) # Use an alternative set of update ops: train_op = tf.contrib.training.create_train_op( total_loss, optimizer, update_ops=my_other_update_ops) # Use a set of update ops in addition to the default updates: tf.add_to_collection(tf.GraphKeys.UPDATE_OPS, my_update0) tf.add_to_collection(tf.GraphKeys.UPDATE_OPS, my_update1) train_op = tf.contrib.training.create_train_op( total_loss, optimizer) # Which is the same as: train_op = tf.contrib.training.create_train_op( total_loss, optimizer, update_ops=tf.get_collection(tf.GraphKeys.UPDATE_OPS)) ****************************************** * Initializing a model from a checkpoint * ****************************************** It is common to want to 'warm-start' a model from a pre-trained checkpoint. One can use a tf.Scaffold and an initializing function to do so. ... # Create the train_op train_op = tf.contrib.training.create_train_op(total_loss, optimizer) # Create the initial assignment op checkpoint_path = '/path/to/old_model_checkpoint' variables_to_restore = tf.contrib.framework.get_model_variables() init_fn = tf.contrib.framework.assign_from_checkpoint_fn( checkpoint_path, variables_to_restore) # Run training. scaffold = tf.Scaffold(init_fn=init_fn) tf.contrib.training.train(train_op, my_log_dir, scaffold=scaffold) *************************************************************************** * Initializing a model from a checkpoint whose variable names don't match * *************************************************************************** At times, a user may want to initialize a new model with values from a checkpoint whose variable names do not match those of the current model. In this case, one needs to create a mapping from the checkpoint variable names to the current model variables. This requires only a small modification of the code above: ... # Creates a model with two variables, var0 and var1 predictions = MyModel(images) ... # Create the train_op train_op = tf.contrib.training.create_train_op(total_loss, optimizer) checkpoint_path = '/path/to/old_model_checkpoint' # Create the mapping: variables_to_restore = { 'name_var_0_in_checkpoint': tf.contrib.framework.get_unique_variable('var0'), 'name_var_1_in_checkpoint': tf.contrib.framework.get_unique_variable('var1') } init_fn = tf.contrib.framework.assign_from_checkpoint_fn( checkpoint_path, variables_to_restore) scaffold = tf.Scaffold(init_fn=init_fn) # Run training. tf.contrib.training.train(train_op, my_log_dir, scaffold=scaffold) ************************************************* * Fine-Tuning Part of a model from a checkpoint * ************************************************* Rather than initializing all of the weights of a given model, we sometimes only want to restore some of the weights from a checkpoint. To do this, one need only filter those variables to initialize as follows: ... # Create the train_op train_op = tf.contrib.training.create_train_op(total_loss, optimizer) checkpoint_path = '/path/to/old_model_checkpoint' # Specify the variables to restore via a list of inclusion or exclusion # patterns: variables_to_restore = tf.contrib.framework.get_variables_to_restore( include=["conv"], exclude=["fc8", "fc9]) # or variables_to_restore = tf.contrib.framework.get_variables_to_restore( exclude=["conv"]) init_fn = tf.contrib.framework.assign_from_checkpoint_fn( checkpoint_path, variables_to_restore) scaffold = tf.Scaffold(init_fn=init_fn) # Run training. tf.contrib.training.train(train_op, my_log_dir, scaffold=scaffold) ****************************************************** * Initializing model variables from values in memory * ****************************************************** One may want to initialize the weights of a model from values coming from an arbitrary source (a text document, matlab file, etc). While this is technically feasible using assign operations, this strategy results in the values of your weights being stored in the graph. For large models, this becomes prohibitively large. However, it's possible to perform this initial assignment without having to store the values of the initial model in the graph itself by using placeholders and a feed dictionary: ... # Create the train_op train_op = tf.contrib.training.create_train_op(total_loss, optimizer) # Create the mapping from variable names to values: var0_initial_value = ReadFromDisk(...) var1_initial_value = ReadFromDisk(...) var_names_to_values = { 'var0': var0_initial_value, 'var1': var1_initial_value, } init_fn = tf.contrib.framework.assign_from_values_fn(var_names_to_values) scaffold = tf.Scaffold(init_fn=init_fn) # Run training. tf.contrib.training.train(train_op, my_log_dir, scaffold=scaffold) """ from __future__ import absolute_import from __future__ import division from __future__ import print_function from tensorflow.python.framework import constant_op from tensorflow.python.framework import ops from tensorflow.python.ops import array_ops from tensorflow.python.ops import clip_ops from tensorflow.python.ops import control_flow_ops from tensorflow.python.ops import variables as tf_variables from tensorflow.python.platform import tf_logging as logging from tensorflow.python.summary import summary from tensorflow.python.training import monitored_session from tensorflow.python.training import optimizer as tf_optimizer from tensorflow.python.training import training_util # TODO(nsilberman): move add_gradients_summaries, clip_gradient_norms and # multiply_gradients into contrib/summaries and contrib/optimizers.py __all__ = [ 'add_gradients_summaries', 'clip_gradient_norms', 'clip_gradient_norms_fn', 'create_train_op', 'multiply_gradients', 'train', ] def add_gradients_summaries(grads_and_vars): """Add summaries to gradients. Args: grads_and_vars: A list of gradient to variable pairs (tuples). Returns: The list of created summaries. """ summaries = [] for grad, var in grads_and_vars: if grad is not None: if isinstance(grad, ops.IndexedSlices): grad_values = grad.values else: grad_values = grad summaries.append( summary.histogram(var.op.name + '_gradient', grad_values)) summaries.append( summary.scalar(var.op.name + '_gradient_norm', clip_ops.global_norm([grad_values]))) else: logging.info('Var %s has no gradient', var.op.name) return summaries def clip_gradient_norms(gradients_to_variables, max_norm): """Clips the gradients by the given value. Args: gradients_to_variables: A list of gradient to variable pairs (tuples). max_norm: the maximum norm value. Returns: A list of clipped gradient to variable pairs. """ clipped_grads_and_vars = [] for grad, var in gradients_to_variables: if grad is not None: if isinstance(grad, ops.IndexedSlices): tmp = clip_ops.clip_by_norm(grad.values, max_norm) grad = ops.IndexedSlices(tmp, grad.indices, grad.dense_shape) else: grad = clip_ops.clip_by_norm(grad, max_norm) clipped_grads_and_vars.append((grad, var)) return clipped_grads_and_vars def clip_gradient_norms_fn(max_norm): """Returns a `transform_grads_fn` function for gradient clipping.""" def clip_norms(gradients_to_variables): return clip_gradient_norms(gradients_to_variables, max_norm) return clip_norms def multiply_gradients(grads_and_vars, gradient_multipliers): """Multiply specified gradients. Args: grads_and_vars: A list of gradient to variable pairs (tuples). gradient_multipliers: A map from either `Variables` or `Variable` op names to the coefficient by which the associated gradient should be scaled. Returns: The updated list of gradient to variable pairs. Raises: ValueError: If `grads_and_vars` is not a list or if `gradient_multipliers` is empty or None or if `gradient_multipliers` is not a dictionary. """ if not isinstance(grads_and_vars, list): raise ValueError('`grads_and_vars` must be a list.') if not gradient_multipliers: raise ValueError('`gradient_multipliers` is empty.') if not isinstance(gradient_multipliers, dict): raise ValueError('`gradient_multipliers` must be a dict.') multiplied_grads_and_vars = [] for grad, var in grads_and_vars: if var in gradient_multipliers or var.op.name in gradient_multipliers: key = var if var in gradient_multipliers else var.op.name if grad is None: raise ValueError('Requested multiple of `None` gradient.') if isinstance(grad, ops.IndexedSlices): tmp = grad.values * constant_op.constant( gradient_multipliers[key], dtype=grad.dtype) grad = ops.IndexedSlices(tmp, grad.indices, grad.dense_shape) else: grad *= constant_op.constant( gradient_multipliers[key], dtype=grad.dtype) multiplied_grads_and_vars.append((grad, var)) return multiplied_grads_and_vars _USE_GLOBAL_STEP = 0 def create_train_op(total_loss, optimizer, global_step=_USE_GLOBAL_STEP, update_ops=None, variables_to_train=None, transform_grads_fn=None, summarize_gradients=False, gate_gradients=tf_optimizer.Optimizer.GATE_OP, aggregation_method=None, colocate_gradients_with_ops=False, check_numerics=True): """Creates an `Operation` that evaluates the gradients and returns the loss. Args: total_loss: A `Tensor` representing the total loss. optimizer: A tf.Optimizer to use for computing the gradients. global_step: A `Tensor` representing the global step variable. If left as `_USE_GLOBAL_STEP`, then tf.contrib.framework.global_step() is used. update_ops: An optional list of updates to execute. If `update_ops` is `None`, then the update ops are set to the contents of the `tf.GraphKeys.UPDATE_OPS` collection. If `update_ops` is not `None`, but it doesn't contain all of the update ops in `tf.GraphKeys.UPDATE_OPS`, a warning will be displayed. variables_to_train: an optional list of variables to train. If None, it will default to all tf.trainable_variables(). transform_grads_fn: A function which takes a single argument, a list of gradient to variable pairs (tuples), performs any requested gradient updates, such as gradient clipping or multipliers, and returns the updated list. summarize_gradients: Whether or not add summaries for each gradient. gate_gradients: How to gate the computation of gradients. See tf.Optimizer. aggregation_method: Specifies the method used to combine gradient terms. Valid values are defined in the class `AggregationMethod`. colocate_gradients_with_ops: Whether or not to try colocating the gradients with the ops that generated them. check_numerics: Whether or not we apply check_numerics. Returns: A `Tensor` that when evaluated, computes the gradients and returns the total loss value. """ if global_step is _USE_GLOBAL_STEP: global_step = training_util.get_or_create_global_step() # Update ops use GraphKeys.UPDATE_OPS collection if update_ops is None. global_update_ops = set(ops.get_collection(ops.GraphKeys.UPDATE_OPS)) if update_ops is None: update_ops = global_update_ops else: update_ops = set(update_ops) if not global_update_ops.issubset(update_ops): logging.warning('update_ops in create_train_op does not contain all the ' ' update_ops in GraphKeys.UPDATE_OPS') # Make sure update_ops are computed before total_loss. if update_ops: with ops.control_dependencies(update_ops): barrier = control_flow_ops.no_op(name='update_barrier') total_loss = control_flow_ops.with_dependencies([barrier], total_loss) if variables_to_train is None: # Default to tf.trainable_variables() variables_to_train = tf_variables.trainable_variables() else: # Make sure that variables_to_train are in tf.trainable_variables() for v in variables_to_train: assert v in tf_variables.trainable_variables() assert variables_to_train # Create the gradients. Note that apply_gradients adds the gradient # computation to the current graph. grads = optimizer.compute_gradients( total_loss, variables_to_train, gate_gradients=gate_gradients, aggregation_method=aggregation_method, colocate_gradients_with_ops=colocate_gradients_with_ops) if transform_grads_fn: grads = transform_grads_fn(grads) # Summarize gradients. if summarize_gradients: with ops.name_scope('summarize_grads'): add_gradients_summaries(grads) # Create gradient updates. grad_updates = optimizer.apply_gradients(grads, global_step=global_step) with ops.name_scope('train_op'): # Make sure total_loss is valid. if check_numerics: total_loss = array_ops.check_numerics(total_loss, 'LossTensor is inf or nan') # Ensure the train_tensor computes grad_updates. train_op = control_flow_ops.with_dependencies([grad_updates], total_loss) # Add the operation used for training to the 'train_op' collection train_ops = ops.get_collection_ref(ops.GraphKeys.TRAIN_OP) if train_op not in train_ops: train_ops.append(train_op) return train_op def train(train_op, logdir, master='', is_chief=True, scaffold=None, hooks=None, chief_only_hooks=None, save_checkpoint_secs=600, save_summaries_steps=100, config=None, max_wait_secs=7200): """Runs the training loop. Args: train_op: A `Tensor` that, when executed, will apply the gradients and return the loss value. logdir: The directory where the graph and checkpoints are saved. master: The URL of the master. is_chief: Specifies whether or not the training is being run by the primary replica during replica training. scaffold: An tf.train.Scaffold instance. hooks: List of `tf.train.SessionRunHook` callbacks which are run inside the training loop. chief_only_hooks: List of `tf.train.SessionRunHook` instances which are run inside the training loop for the chief trainer only. save_checkpoint_secs: The frequency, in seconds, that a checkpoint is saved using a default checkpoint saver. If `save_checkpoint_secs` is set to `None`, then the default checkpoint saver isn't used. save_summaries_steps: The frequency, in number of global steps, that the summaries are written to disk using a default summary saver. If `save_summaries_steps` is set to `None`, then the default summary saver isn't used. config: An instance of `tf.ConfigProto`. max_wait_secs: Maximum time workers should wait for the session to become available. This should be kept relatively short to help detect incorrect code, but sometimes may need to be increased if the chief takes a while to start up. Returns: the value of the loss function after training. Raises: ValueError: if `logdir` is `None` and either `save_checkpoint_secs` or `save_summaries_steps` are `None. """ if logdir is None and is_chief: if save_summaries_steps: raise ValueError( 'logdir cannot be None when save_summaries_steps is not None') if save_checkpoint_secs: raise ValueError( 'logdir cannot be None when save_checkpoint_secs is not None') with monitored_session.MonitoredTrainingSession( master=master, is_chief=is_chief, checkpoint_dir=logdir, scaffold=scaffold, hooks=hooks, chief_only_hooks=chief_only_hooks, save_checkpoint_secs=save_checkpoint_secs, save_summaries_steps=save_summaries_steps, config=config, max_wait_secs=max_wait_secs) as session: loss = None while not session.should_stop(): loss = session.run(train_op) return loss

f72e1011955a719906527c88ace33c87f218c56f

py

Python

docs/conf.py

kponder/astrorapid

91053af8049724a07d1f55baf4e1f60fc36b1101

2019-01-15T19:40:11.000Z

2020-12-17T11:36:18.000Z

docs/conf.py

kponder/astrorapid

91053af8049724a07d1f55baf4e1f60fc36b1101

2019-07-19T15:29:19.000Z

2022-03-12T00:59:37.000Z

docs/conf.py

kponder/astrorapid

91053af8049724a07d1f55baf4e1f60fc36b1101

2019-02-19T20:35:08.000Z

2021-07-16T05:56:28.000Z

# -*- coding: utf-8 -*- # # Configuration file for the Sphinx documentation builder. # # This file does only contain a selection of the most common options. For a # full list see the documentation: # http://www.sphinx-doc.org/en/master/config # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # import os import sys sys.path.insert(0, os.path.abspath('.')) sys.path.insert(0, os.path.abspath('./..')) sys.path.insert(0, os.path.abspath('./../..')) sys.path.insert(0, 'astrorapid') sys.path.insert(0, 'astrorapid/read_from_database') sys.path.insert(0, './../astrorapid') sys.path.insert(0, './../astrorapid/read_from_database') # -- Project information ----------------------------------------------------- project = 'astrorapid' copyright = '2019, Daniel Muthukrishna' author = 'Daniel Muthukrishna' # The short X.Y version version = '' # The full version, including alpha/beta/rc tags release = '' # -- General configuration --------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. # # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.coverage', 'sphinx.ext.mathjax', 'sphinx.ext.viewcode', 'sphinx.ext.githubpages', 'sphinx.ext.autosummary' ] autoclass_content = 'both' # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] source_suffix = '.rst' # The master toctree document. master_doc = 'index' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = 'Python' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = 'sphinx_rtd_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # # html_theme_options = {} # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # Custom sidebar templates, must be a dictionary that maps document names # to template names. # # The default sidebars (for documents that don't match any pattern) are # defined by theme itself. Builtin themes are using these templates by # default: ``['localtoc.html', 'relations.html', 'sourcelink.html', # 'searchbox.html']``. # # html_sidebars = {} # -- Options for HTMLHelp output --------------------------------------------- # Output file base name for HTML help builder. htmlhelp_basename = 'astrorapiddoc' # -- Options for LaTeX output ------------------------------------------------ latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', # Additional stuff for the LaTeX preamble. # # 'preamble': '', # Latex figure (float) alignment # # 'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ (master_doc, 'astrorapid.tex', 'astrorapid Documentation', 'Daniel Muthukrishna', 'manual'), ] # -- Options for manual page output ------------------------------------------ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, 'astrorapid', 'astrorapid Documentation', [author], 1) ] # -- Options for Texinfo output ---------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ (master_doc, 'astrorapid', 'astrorapid Documentation', author, 'astrorapid', 'One line description of project.', 'Miscellaneous'), ] # -- Options for Epub output ------------------------------------------------- # Bibliographic Dublin Core info. epub_title = project # The unique identifier of the text. This can be a ISBN number # or the project homepage. # # epub_identifier = '' # A unique identification for the text. # # epub_uid = '' # A list of files that should not be packed into the epub file. epub_exclude_files = ['search.html'] # -- Extension configuration -------------------------------------------------

f72e5d9a801e6d998e27b90743043c49babb6526

py

Python

jumpscale/packages/vdc_dashboard/services/provision_wallet_billing.py

threefoldtech/js-sdk

811f783ac34a60225175bab2d806802a87b9d5c7

2020-09-02T09:05:08.000Z

2022-03-12T02:43:24.000Z

jumpscale/packages/vdc_dashboard/services/provision_wallet_billing.py

threefoldtech/js-sdk

811f783ac34a60225175bab2d806802a87b9d5c7

2020-06-15T11:46:10.000Z

2022-03-24T22:12:41.000Z

jumpscale/packages/vdc_dashboard/services/provision_wallet_billing.py

threefoldtech/js-sdk

811f783ac34a60225175bab2d806802a87b9d5c7

2020-09-29T06:50:35.000Z

2021-06-14T03:30:52.000Z

from jumpscale.loader import j from jumpscale.packages.vdc.billing import auto_extend_billing from jumpscale.tools.servicemanager.servicemanager import BackgroundService class AutoExtendbillingService(BackgroundService): def __init__(self, interval=60 * 60, *args, **kwargs): """Provisioning wallet service that will run every hour to extend the VDC pool """ super().__init__(interval, *args, **kwargs) def job(self): auto_extend_billing() j.logger.info("Auto extend billing service") service = AutoExtendbillingService()

f72e6942e7acd082f6cba1fa9c3d70a58320e52f

py

Python

python/math/0204_count_primes.py

linshaoyong/leetcode

ea052fad68a2fe0cbfa5469398508ec2b776654f

2019-07-15T13:23:57.000Z

2020-01-22T03:12:01.000Z

python/math/0204_count_primes.py

linshaoyong/leetcode

ea052fad68a2fe0cbfa5469398508ec2b776654f

python/math/0204_count_primes.py

linshaoyong/leetcode

ea052fad68a2fe0cbfa5469398508ec2b776654f

2019-07-24T02:15:31.000Z

2019-07-24T02:15:31.000Z

import math class Solution: def countPrimes(self, n): """ :type n: int :rtype: int 厄拉多塞筛法 比如求20以内质数的个数, 首先0,1不是质数。 2是第一个质数,然后把20以内所有2的倍数划去。 2后面紧跟的数即为下一个质数3，然后把3所有的倍数划去。 3后面紧跟的数即为下一个质数5，再把5所有的倍数划去，以此类推。 """ if n < 2: return 0 s = [1] * n s[0] = s[1] = 0 for i in range(2, int(math.sqrt(n)) + 1): if s[i] == 1: s[i * i:n:i] = [0] * int((n - i * i - 1) / i + 1) return sum(s) def test_count_primes(): s = Solution() assert 4 == s.countPrimes(10)

f72e8e165d3d5f54741251e1676396f0a12b4e4f

py

Python

lian/ssh_deploy.py

catroll/lian

405fd0c8c4ce8557609bf595431284a07e7b443e

lian/ssh_deploy.py

catroll/lian

405fd0c8c4ce8557609bf595431284a07e7b443e

lian/ssh_deploy.py

catroll/lian

405fd0c8c4ce8557609bf595431284a07e7b443e

# -*- coding: utf-8 -*- import logging import os import re import time from collections import OrderedDict LOG = logging.getLogger(__name__) def md5sum_command(directory='.', find_type='f', match='', not_match=''): return ' '.join([i for i in [ 'find', directory, ('-type %s' % find_type) if find_type else '', '-regextype posix-extended' if match or not_match else '', ('-regex %s' % match) if match else '', ('! -regex "%s"' % not_match) if not_match else '', """-print0 | xargs -0 md5sum | awk '{printf "%-50s %s\\n", $2, $1}' | sort""" ] if i]) def check_sum(chain, local_path, remote_path, *md5sum_args, **md5sum_kwargs): title = re.sub('[^a-zA-Z0-9]', '-', local_path) + '.' + time.strftime('%Y%m%d-%H%I%S') cmd_md5sum = md5sum_command(*md5sum_args, **md5sum_kwargs) # ---------- get md5sum ---------- # locally command = 'cd ' + local_path + '; ' + cmd_md5sum LOG.info('local command: %s', command) content = os.popen(command).read() with open('/tmp/%s.a.txt' % title, 'w') as _file: _file.write(content) local_sums = OrderedDict((_file, _sum) for _file, _sum in [line.split() for line in content.splitlines()]) # remotely command = 'cd ' + remote_path + '; ' + cmd_md5sum LOG.info('remote command: %s', command) code, out, err = chain.execute('cd ' + remote_path + '; ' + cmd_md5sum, buff_size=1024000) out = out.decode('utf-8') with open('/tmp/%s.b.txt' % title, 'w') as _file: _file.write(out) remote_sums = OrderedDict((_file, _sum) for _file, _sum in [line.split() for line in out.splitlines()]) # ---------- compare result ---------- LOG.info('*' * 50) LOG.info('') is_synced = True for _file in local_sums: if _file not in remote_sums: is_synced = False LOG.info(u'🐈 [LOCAL] ' + _file) continue if local_sums[_file] != remote_sums[_file]: is_synced = False LOG.info(u'🐍 [DIFF] ' + _file) continue # LOG.info('[SAME] ' + _file + ' ignore it') for _file in remote_sums: if _file not in local_sums: is_synced = False LOG.info(u'🐦 [REMOTE] ' + _file) if is_synced: LOG.info(u'㊗️ ㊗️ ㊗️ Perfect!!! ㊗️ ㊗️ ㊗️'.center(44)) LOG.info('') LOG.info('*' * 50) def sftp_download(chain, files_will_transferred): for remote_path, local_path in files_will_transferred: try: chain.use().download(remote_path, local_path) except Exception as error: LOG.warning(error) def download_files(chain, local_path, remote_path, files=None): # download specified files if not files: LOG.debug('Download, but no file specified, over!') return move_tasks = [(os.path.join(remote_path, path), os.path.join(local_path, path)) for path in files] sftp_download(chain, move_tasks) def sftp_upload(chain, files_will_transferred): """ SFTP upload Args: chain: object of SSHChain files_will_transferred: list[tuple] """ LOG.info(files_will_transferred) for local_path, remote_path in files_will_transferred: chain.use().upload(local_path, remote_path) def upload_files(chain, local_path, remote_path, files=None, ignore_patterns=None): """Upload local files or directory, can ignore some files by pattern Args: chain: local_path: remote_path: files: ignore_patterns: """ files = files or [] ignore_patterns = ignore_patterns or [] re_ignore = re.compile('(%s)' % (')|('.join(ignore_patterns))) if ignore_patterns else '' move_tasks = [] for path in files: fullpath = os.path.join(local_path, path) if not os.path.exists(fullpath): LOG.error('The file need uploaded not found: %s', fullpath) exit() if os.path.isfile(fullpath): move_tasks.append((fullpath, os.path.join(remote_path, path))) continue assert os.path.isdir(fullpath) for root, dirs, _files in os.walk(fullpath): for _file in _files: _fullpath = os.path.join(root, _file) if re_ignore and re_ignore.search(_fullpath): continue relpath = os.path.relpath(_fullpath, local_path) move_tasks.append((_fullpath, os.path.join(remote_path, relpath))) sftp_upload(chain, move_tasks) def file_sync(chain, local_path, remote_path, files_upload=None, ignore_patterns=None, # upload arguments files_download=None): # download arguments if files_download: download_files(chain, local_path, remote_path, files_download) if files_upload: upload_files(chain, local_path, remote_path, files_upload, ignore_patterns) ACTIONS = 'check', 'sync', 'all', def main(chain, local_path, remote_path, action='check', files_upload=None, ignore_patterns=None, files_download=None, *md5sum_args, **md5sum_kwargs): """ Args: chain: object of SSHChain local_path: str, absolute path remote_path: str, absolute path action: str files_upload: list of files to upload ignore_patterns files_download: list of files to download md5sum_args: md5sum_kwargs: like: directory='.', find_type='f', match='', not_match='' """ if action not in ACTIONS: return def _file_sync(): file_sync(chain, local_path, remote_path, files_upload, ignore_patterns, files_download) def _check_sum(): check_sum(chain, local_path, remote_path, *md5sum_args, **md5sum_kwargs) if action == 'sync': _file_sync() return if action == 'check': _check_sum() return _file_sync() _check_sum()

f72e975ec68de10ec951352b654b92d2aa5f1c53

py

Python

tests/xgboost_data/models.py

wmonteiro92/xmoai-examples

0286d57e15cb60693f57cdff386cbb246787442b

2021-03-22T11:31:00.000Z

2021-03-22T11:31:00.000Z

tests/xgboost_data/models.py

wmonteiro92/xmoai-examples

0286d57e15cb60693f57cdff386cbb246787442b

tests/xgboost_data/models.py

wmonteiro92/xmoai-examples

0286d57e15cb60693f57cdff386cbb246787442b

# -*- coding: utf-8 -*- """ Created on Fri Jul 17 21:16:08 2020 @author: wmonteiro92 """ from xgboost import XGBRegressor, XGBClassifier def train_ml_model(X, y, algorithm, random_state=0): """Train one dataset in Python. :param X: the input values. :type X: np.array :param y: the target values. :type y: np.array :param algorithm: the machine learning model to use. Allowed values are `XGBClassifier` and `XGBRegressor`. :type algorithm: str :param random_state: the seed. Default is 0. :type random_state: Integer :return: the trained machine learning model. :rtype: Object """ if algorithm == 'XGBClassifier': model = XGBClassifier(random_state=random_state) elif algorithm == 'XGBRegressor': model = XGBRegressor(random_state=random_state) model.fit(X, y) return model

f72e9dda78207301c3e7659b1baf989a356f877b

py

Python

aesara/tensor/nnet/conv3d2d.py

anirudhacharya/Theano-PyMC

55f54243cf88397b032ebc7121d1090ee91aea7d

aesara/tensor/nnet/conv3d2d.py

anirudhacharya/Theano-PyMC

55f54243cf88397b032ebc7121d1090ee91aea7d

aesara/tensor/nnet/conv3d2d.py

anirudhacharya/Theano-PyMC

55f54243cf88397b032ebc7121d1090ee91aea7d

import aesara from aesara import tensor as at from aesara.gradient import DisconnectedType from aesara.graph.basic import Apply from aesara.graph.op import Op from aesara.graph.opt import TopoOptimizer, copy_stack_trace, local_optimizer def get_diagonal_subtensor_view(x, i0, i1): """ Helper function for DiagonalSubtensor and IncDiagonalSubtensor. Notes ----- It returns a partial view of x, not a partial copy. """ # We have to cast i0 and i0 to int because python # do not support indexing with 0-dim, 'int*' ndarrays. i0 = int(i0) i1 = int(i1) if x.shape[i0] < x.shape[i1]: raise NotImplementedError("is this allowed?") idx = [slice(None)] * x.ndim idx[i0] = slice(x.shape[i1] - 1, None, None) xview = x.__getitem__(tuple(idx)) strides = list(xview.strides) if x.shape[i1] != 1: strides[i1] -= strides[i0] xview.strides = strides return xview class DiagonalSubtensor(Op): """ Return a form a nd diagonal subtensor. Parameters ---------- x n-d tensor i0 Axis index in x i1 Axis index in x Notes ----- Work on the GPU. Extended summary ---------------- ``x`` is some n-dimensional tensor, but this Op only deals with a matrix-shaped slice, using axes i0 and i1. Without loss of generality, suppose that ``i0`` picks out our ``row`` dimension, and i1 the ``column`` dimension. So the relevant part of ``x`` is some matrix ``u``. Suppose it has 7 rows and 4 columns:: [ 0 0 0 0 ] [ 0 0 0 0 ] [ 0 0 0 0 ] [ 0 0 0 0 ] [ 0 0 0 0 ] [ 0 0 0 0 ] The view returned by this function is also a matrix. It's a thick, diagonal ``stripe`` across u that discards the lower left triangle and the upper right triangle: [ x 0 0 0 ] [ x x 0 0 ] [ x x x 0 ] [ 0 x x x ] [ 0 0 x x ] [ 0 0 0 x ] In this case the return value would be this view of shape 3x4. The returned view has the same number of dimensions as the input ``x``, and the only difference is that the shape along dimension ``i0`` has been reduced by ``shape[i1] - 1`` because of the triangles that got chopped out. The NotImplementedError is meant to catch the case where shape[i0] is too small for the stripe to reach across the matrix, in which case it's not clear what this function should do. Maybe always raise an error. I'd look back to the call site in the Conv3D to see what's necessary at that point. """ __props__ = ("inplace",) def __str__(self): if self.inplace: return "%s{inplace}" % self.__class__.__name__ return f"{self.__class__.__name__}" def __init__(self, inplace=False): self.inplace = inplace if inplace: self.view_map = {0: [0]} def make_node(self, x, i0, i1): _i0 = at.as_tensor_variable(i0) _i1 = at.as_tensor_variable(i1) return Apply(self, [x, _i0, _i1], [x.type()]) def perform(self, node, inputs, output_storage): xview = get_diagonal_subtensor_view(*inputs) if self.inplace: output_storage[0][0] = xview else: output_storage[0][0] = xview.copy() def grad(self, inputs, g_outputs): z = at.zeros_like(inputs[0]) gx = inc_diagonal_subtensor(z, inputs[1], inputs[2], g_outputs[0]) return [gx, DisconnectedType()(), DisconnectedType()()] def connection_pattern(self, node): rval = [[True], [False], [False]] return rval diagonal_subtensor = DiagonalSubtensor(False) class IncDiagonalSubtensor(Op): """ The gradient of DiagonalSubtensor. """ __props__ = ("inplace",) def __str__(self): if self.inplace: return "%s{inplace}" % self.__class__.__name__ return f"{self.__class__.__name__}" def __init__(self, inplace=False): self.inplace = inplace if inplace: self.destroy_map = {0: [0]} def make_node(self, x, i0, i1, amt): _i0 = at.as_tensor_variable(i0) _i1 = at.as_tensor_variable(i1) return Apply(self, [x, _i0, _i1, amt], [x.type()]) def perform(self, node, inputs, output_storage): x, i0, i1, amt = inputs if not self.inplace: x = x.copy() xview = get_diagonal_subtensor_view(x, i0, i1) xview += amt output_storage[0][0] = x def grad(self, inputs, g_outputs): x, i0, i1, amt = inputs gy = g_outputs[0] return [ gy, DisconnectedType()(), DisconnectedType()(), diagonal_subtensor(gy, i0, i1), ] def connection_pattern(self, node): rval = [[True], [False], [False], [True]] return rval inc_diagonal_subtensor = IncDiagonalSubtensor(False) def conv3d( signals, filters, signals_shape=None, filters_shape=None, border_mode="valid" ): """ Convolve spatio-temporal filters with a movie. It flips the filters. Parameters ---------- signals Timeseries of images whose pixels have color channels. Shape: [Ns, Ts, C, Hs, Ws]. filters Spatio-temporal filters. Shape: [Nf, Tf, C, Hf, Wf]. signals_shape None or a tuple/list with the shape of signals. filters_shape None or a tuple/list with the shape of filters. border_mode One of 'valid', 'full' or 'half'. Notes ----- Another way to define signals: (batch, time, in channel, row, column) Another way to define filters: (out channel,time,in channel, row, column) For the GPU, use nnet.conv3d. See Also -------- Someone made a script that shows how to swap the axes between both 3d convolution implementations in Aesara. See the last `attachment <https://groups.google.com/d/msg/aesara-users/1S9_bZgHxVw/0cQR9a4riFUJ>`_ """ if isinstance(border_mode, str): border_mode = (border_mode, border_mode, border_mode) if signals_shape is None: _signals_shape_5d = signals.shape else: _signals_shape_5d = signals_shape if filters_shape is None: _filters_shape_5d = filters.shape else: _filters_shape_5d = filters_shape Ns, Ts, C, Hs, Ws = _signals_shape_5d Nf, Tf, C, Hf, Wf = _filters_shape_5d _signals_shape_4d = (Ns * Ts, C, Hs, Ws) _filters_shape_4d = (Nf * Tf, C, Hf, Wf) if border_mode[1] != border_mode[2]: raise NotImplementedError("height and width bordermodes must match") conv2d_signal_shape = _signals_shape_4d conv2d_filter_shape = _filters_shape_4d if signals_shape is None: conv2d_signal_shape = None if filters_shape is None: conv2d_filter_shape = None out_4d = aesara.tensor.nnet.conv2d( signals.reshape(_signals_shape_4d), filters.reshape(_filters_shape_4d), input_shape=conv2d_signal_shape, filter_shape=conv2d_filter_shape, border_mode=border_mode[1], ) # ignoring border_mode[2] # compute the intended output size if border_mode[1] == "valid": Hout = Hs - Hf + 1 Wout = Ws - Wf + 1 elif border_mode[1] == "full": Hout = Hs + Hf - 1 Wout = Ws + Wf - 1 elif border_mode[1] == "half": Hout = Hs - (Hf % 2) + 1 Wout = Ws - (Wf % 2) + 1 elif border_mode[1] == "same": raise NotImplementedError() else: raise ValueError("invalid border mode", border_mode[1]) # reshape the temporary output to restore its original size out_tmp = out_4d.reshape((Ns, Ts, Nf, Tf, Hout, Wout)) # now sum out along the Tf to get the output # but we have to sum on a diagonal through the Tf and Ts submatrix. if Tf == 1: # for Tf==1, no sum along Tf, the Ts-axis of the output is unchanged! out_5d = out_tmp.reshape((Ns, Ts, Nf, Hout, Wout)) else: # for some types of convolution, pad out_tmp with zeros if border_mode[0] == "valid": Tpad = 0 elif border_mode[0] == "full": Tpad = Tf - 1 elif border_mode[0] == "half": Tpad = Tf // 2 elif border_mode[0] == "same": raise NotImplementedError() else: raise ValueError("invalid border mode", border_mode[0]) if Tpad == 0: out_5d = diagonal_subtensor(out_tmp, 1, 3).sum(axis=3) else: # pad out_tmp with zeros before summing over the diagonal out_tmp_padded = at.zeros( dtype=out_tmp.dtype, shape=(Ns, Ts + 2 * Tpad, Nf, Tf, Hout, Wout) ) out_tmp_padded = aesara.tensor.subtensor.set_subtensor( out_tmp_padded[:, Tpad : (Ts + Tpad), :, :, :, :], out_tmp ) out_5d = diagonal_subtensor(out_tmp_padded, 1, 3).sum(axis=3) return out_5d @local_optimizer([DiagonalSubtensor, IncDiagonalSubtensor]) def local_inplace_DiagonalSubtensor(fgraph, node): """Also work for IncDiagonalSubtensor.""" if ( isinstance(node.op, (DiagonalSubtensor, IncDiagonalSubtensor)) and not node.op.inplace ): new_op = node.op.__class__(inplace=True) new_node = new_op(*node.inputs) copy_stack_trace(node.outputs[0], new_node) return [new_node] return False aesara.compile.optdb.register( "local_inplace_DiagonalSubtensor", TopoOptimizer( local_inplace_DiagonalSubtensor, failure_callback=TopoOptimizer.warn_inplace ), 60, "fast_run", "inplace", )

f72f19778b0b87aa95ac05b779fa868ad2422b2a

py

Python

pybat/__init__.py

mbercx/pybat

e0cf610fd06a97979f5ec70757406de1f9a788ef

2019-04-08T13:10:15.000Z

2021-07-04T07:23:49.000Z

pybat/__init__.py

mbercx/pybat

e0cf610fd06a97979f5ec70757406de1f9a788ef

2019-02-28T12:51:57.000Z

2019-02-28T12:51:57.000Z

pybat/__init__.py

mbercx/pybat

e0cf610fd06a97979f5ec70757406de1f9a788ef

2018-07-30T12:58:35.000Z

2020-03-05T20:09:46.000Z

# These import commands make importing core classes easier, e.g. you can just import # Cathode using: # # from pybat import Cathode # # Instead of: # # from pybat.core import Cathode # from pybat.core import Cathode, LiRichCathode, Dimer, DimerNEBAnalysis

f72f39ea13255cbce714cd52ecd6820c01e3e27b

py

Python

tests/test_phase_change.py

volpatto/chemicals

721904ee17604f5e8685b0e5fff12e0bac567f73

tests/test_phase_change.py

volpatto/chemicals

721904ee17604f5e8685b0e5fff12e0bac567f73

tests/test_phase_change.py

volpatto/chemicals

721904ee17604f5e8685b0e5fff12e0bac567f73

# -*- coding: utf-8 -*- """Chemical Engineering Design Library (ChEDL). Utilities for process modeling. Copyright (C) 2016, Caleb Bell <Caleb.Andrew.Bell@gmail.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 pytest from fluids.numerics import assert_close, assert_close1d from chemicals.phase_change import * from chemicals.phase_change import (Hvap_data_CRC, Hfus_data_CRC, Hvap_data_Gharagheizi, Hsub_data_Gharagheizi, Tb_data_Yaws, Tm_ON_data, phase_change_data_Perrys2_150, phase_change_data_Alibakhshi_Cs, phase_change_data_VDI_PPDS_4) from chemicals.miscdata import CRC_inorganic_data, CRC_organic_data from chemicals.identifiers import check_CAS def test_Watson(): Hvap = Watson(T=320, Hvap_ref=43908, T_ref=300.0, Tc=647.14) assert_close(Hvap, 42928.990094915454, rtol=1e-12) def test_Clapeyron(): Hvap = Clapeyron(294.0, 466.0, 5.55E6) assert_close(Hvap, 26512.36357131963) # Test at 1/2 bar, sZ=0.98 Hvap = Clapeyron(264.0, 466.0, 5.55E6, 0.98, 5E4) assert_close(Hvap, 23370.947571814384) def test_Pitzer(): Hvap = Pitzer(452, 645.6, 0.35017) assert_close(Hvap, 36696.749078320056) def test_SMK(): Hvap = SMK(553.15, 751.35, 0.302) assert_close(Hvap, 39866.18999046232) def test_MK(): # Problem in article for SMK function. Hv1 = MK(553.15, 751.35, 0.302) # data in [1]_., should give 26.43 KJ/mol Hv2 = MK(298.15, 469.69, 0.2507) assert_close(Hv1, 38728.00667307733, rtol=1e-12) assert_close(Hv2, 25940.988533726406, rtol=1e-12) def test_Velasco(): Hv1 = Velasco(553.15, 751.35, 0.302) Hv2 = Velasco(333.2, 476.0, 0.5559) assert_close(Hv1, 39524.251054691274, rtol=1e-12) assert_close(Hv2, 33299.428636069264, rtol=1e-12) def test_Riedel(): # same problem as in Perry's examples Hv1 = Riedel(294.0, 466.0, 5.55E6) # Pyridine, 0.0% err vs. exp: 35090 J/mol; from Poling [2]_. Hv2 = Riedel(388.4, 620.0, 56.3E5) assert_close(Hv1, 26828.59040728512, rtol=1e-12) assert_close(Hv2, 35089.80179000598, rtol=1e-12) def test_Chen(): Hv1 = Chen(294.0, 466.0, 5.55E6) assert_close(Hv1, 26705.902558030946) def test_Liu(): Hv1 = Liu(294.0, 466.0, 5.55E6) assert_close(Hv1, 26378.575260517395) def test_Vetere(): Hv1 = Vetere(294.0, 466.0, 5.55E6) assert_close(Hv1, 26363.43895706672) def test_Hvap_CRC_data(): HvapTb_tot = Hvap_data_CRC['HvapTb'].sum() assert_close(HvapTb_tot, 30251890.0) Hvap298_tot = Hvap_data_CRC['Hvap298'].sum() assert_close(Hvap298_tot, 29343710.0) Tb_tot = Hvap_data_CRC['Tb'].sum() assert_close(Tb_tot, 407502.95600000001) assert Hvap_data_CRC.index.is_unique assert Hvap_data_CRC.shape == (926, 5) assert all([check_CAS(i) for i in list(Hvap_data_CRC.index)]) def test_Hfus_CRC_data(): Hfus_total = Hfus_data_CRC['Hfus'].sum() assert_close(Hfus_total, 29131241) assert Hfus_data_CRC.index.is_unique assert Hfus_data_CRC.shape == (1112, 3) assert all([check_CAS(i) for i in list(Hfus_data_CRC.index)]) def test_Hfus(): assert_close(Hfus('462-06-6', method='CRC'), 11310.0, rtol=1e-12) assert_close(Hfus('462-06-6'), 11310.0, rtol=1e-12) assert_close(Hfus(CASRN='75-07-0'), 2310.0) assert Hfus(CASRN='75000-07-0') is None assert Hfus_methods('7732-18-5') == ['CRC'] def test_Gharagheizi_Hvap_data(): # 51 CAS number DO NOT validate Hvap298_tot = Hvap_data_Gharagheizi['Hvap298'].sum() assert_close(Hvap298_tot, 173584900) assert Hvap_data_Gharagheizi.index.is_unique assert Hvap_data_Gharagheizi.shape == (2730, 2) def test_Gharagheizi_Hsub_data(): tots = [Hsub_data_Gharagheizi[i].sum() for i in ['Hsub', 'error']] assert_close(tots[0], 130537650) assert_close(tots[1], 1522960.0) assert Hsub_data_Gharagheizi.index.is_unique assert Hsub_data_Gharagheizi.shape == (1241, 3) def test_Yaws_Tb_data(): tot = Tb_data_Yaws.sum() assert_close(tot, 6631287.51) assert Tb_data_Yaws.index.is_unique assert Tb_data_Yaws.shape == (13461, 1) @pytest.mark.slow def test_Yaws_Tb_CAS_valid(): assert all([check_CAS(i) for i in Tb_data_Yaws.index]) def test_Tm_ON_data(): tot = Tm_ON_data.sum() assert_close(tot, 4059989.425) assert Tm_ON_data.shape == (11549, 1) assert Tm_ON_data.index.is_unique @pytest.mark.slow def test_Tm_ON_data_CAS_valid(): assert all([check_CAS(i) for i in Tm_ON_data.index]) def test_Perrys2_150_data(): # rtol=2E-4 for Tmin; only helium-4 needs a higher tolerance # Everything hits 0 at Tmax except Difluoromethane, methane, and water; # those needed their Tmax adjusted to their real Tc. # C1 is divided by 1000, to give units of J/mol instead of J/kmol # Terephthalic acid removed, was a constant value only. assert all([check_CAS(i) for i in phase_change_data_Perrys2_150.index]) tots_calc = [phase_change_data_Perrys2_150[i].abs().sum() for i in [u'Tc', u'C1', u'C2', u'C3', u'C4', u'Tmin', u'Tmax']] tots = [189407.42499999999, 18617223.739999998, 174.34494000000001, 112.51209900000001, 63.894040000000004, 70810.849999999991, 189407.005] assert_close1d(tots_calc, tots) assert phase_change_data_Perrys2_150.index.is_unique assert phase_change_data_Perrys2_150.shape == (344, 8) def test_Alibakhshi_Cs_data(): # Oops, a bunch of these now-lonely coefficients have an invalid CAS... # assert all([check_CAS(i) for i in phase_change_data_Alibakhshi_Cs.index]) tots_calc = [phase_change_data_Alibakhshi_Cs[i].abs().sum() for i in [u'C']] tots = [28154.361500000003] assert_close1d(tots_calc, tots) assert phase_change_data_Alibakhshi_Cs.index.is_unique assert phase_change_data_Alibakhshi_Cs.shape == (1890, 2) def test_VDI_PPDS_4_data(): """I believe there are no errors here.""" assert all([check_CAS(i) for i in phase_change_data_VDI_PPDS_4.index]) tots_calc = [phase_change_data_VDI_PPDS_4[i].abs().sum() for i in [u'A', u'B', u'C', u'D', u'E', u'Tc', u'MW']] tots = [1974.2929800000002, 2653.9399000000003, 2022.530649, 943.25633100000005, 3124.9258610000002, 150142.28, 27786.919999999998] assert_close1d(tots_calc, tots) assert phase_change_data_VDI_PPDS_4.index.is_unique assert phase_change_data_VDI_PPDS_4.shape == (272, 8) @pytest.mark.slow @pytest.mark.fuzz def test_Tb_all_values(): s1 = CRC_inorganic_data.index[CRC_inorganic_data['Tb'].notnull()] s2 = CRC_organic_data.index[CRC_organic_data['Tb'].notnull()] s3 = Tb_data_Yaws.index tots = [] tots_exp = [639213.2310000042, 2280667.079999829, 6631287.510000873] # These should match the sums of the respective series for s, method in zip([s1, s2, s3], ['CRC_INORG', 'CRC_ORG', 'YAWS']): tots.append(sum([Tb(i, method=method) for i in s])) assert_close1d(tots, tots_exp, rtol=1e-11) s = set(); s.update(s1); s.update(s2); s.update(s3) assert len(s) == 13868 def test_Tb(): # CRC_inorg, CRC org, Yaws Tbs_calc = Tb('993-50-0'), Tb('626-94-8'), Tb('7631-99-4') Tbs = [399.15, 412.15, 653.15] assert_close1d(Tbs, Tbs_calc) hits = [Tb_methods(i) for i in ['993-50-0', '626-94-8', '7631-99-4']] assert hits == [['CRC_INORG'], ['CRC_ORG'], ['YAWS']] with pytest.raises(Exception): Tb('993-50-0', method='BADMETHOD') assert None == Tb('9923443-50-0') assert [] == Tb_methods('9923443-50-0') w_methods = Tb_methods('7732-18-5') assert w_methods == ['CRC_INORG', 'YAWS'] Tbs = [Tb('7732-18-5', method=i) for i in w_methods] assert_close1d(Tbs, [373.124, 373.15]) @pytest.mark.slow @pytest.mark.fuzz def test_Tm_all_values(): s1 = CRC_inorganic_data.index[CRC_inorganic_data['Tm'].notnull()] s2 = CRC_organic_data.index[CRC_organic_data['Tm'].notnull()] s3 = Tm_ON_data.index tots = [] tots_exp = [1543322.6125999668, 2571284.480399755, 4059989.4249993376] # These should match the sums of the respective series for s, method in zip([s1, s2, s3], ['CRC_INORG', 'CRC_ORG', 'OPEN_NTBKM']): tots.append(sum([Tm(i, method=method) for i in s])) assert_close1d(tots, tots_exp, rtol=1e-11) s = set(); s.update(s1); s.update(s2); s.update(s3) assert len(s) == 14723 def test_Tm(): # Open notebook, CRC organic, CRC inorg Tms_calc = Tm('996-50-9'), Tm('999-78-0'), Tm('993-50-0') Tms = [263.15, 191.15, 274.15] assert_close1d(Tms, Tms_calc) hits = [Tm_methods(i) for i in ['996-50-9', '999-78-0', '993-50-0']] assert hits == [['OPEN_NTBKM'], ['CRC_ORG'], ['CRC_INORG']] with pytest.raises(Exception): Tm('993-50-0', method='BADMETHOD') assert Tm('9923443-50-0') is None assert [] == Tm_methods('9923443-50-0') w_methods = Tm_methods('7732-18-5') assert w_methods == ['OPEN_NTBKM', 'CRC_INORG'] Tms = [Tm('7732-18-5', method=i) for i in w_methods] assert_close1d(Tms, [273.15, 273.15]) def test_Alibakhshi(): Hvap = Alibakhshi(T=320.0, Tc=647.14, C=-16.7171) assert_close(Hvap, 41961.30490225752, rtol=1e-13) def test_PPDS12(): Hvap = PPDS12(300.0, 591.75, 4.60584, 13.97224, -10.592315, 2.120205, 4.277128) assert_close(Hvap, 37948.76862035927, rtol=1e-13)

f72f3a0ab9d913c2109ddb7b9fece41c54d596c4

py

Python

typhon/retrieval/common.py

gerritholl/typhon

dbde147be12922ec730bd072dc4797c9da9a6d6b

typhon/retrieval/common.py

gerritholl/typhon

dbde147be12922ec730bd072dc4797c9da9a6d6b

typhon/retrieval/common.py

gerritholl/typhon

dbde147be12922ec730bd072dc4797c9da9a6d6b

from ast import literal_eval import copy from importlib import import_module import json import numpy as np import pandas as pd from sklearn.pipeline import Pipeline from typhon.utils import to_array __all__ = [ 'RetrievalProduct', ] class NotTrainedError(Exception): """Should be raised if someone runs a non-trained retrieval product """ def __init__(self, *args): message = "You must train this retrieval product before running it!" Exception.__init__(self, message, *args) class RetrievalProduct: """Retrieval that can be trained with data and stored to json files This is basically a wrapper around the scikit-learn estimator and trainer classes and makes it possible to save the trained models as json file. To save this object to a json file, the additional package json_tricks is required. """ def __init__(self, verbose=False): """Initialize a Retriever object Args: verbose: The higher this value is the more debug messages are printed. Default is False. """ # The trainer and/or model for this retriever: self.estimator = None self.verbose = verbose self._inputs = [] self._outputs = [] @property def inputs(self): return self._inputs @property def outputs(self): return self._outputs @staticmethod def _import_class(module_name, class_name): """Import a class dynamically to the namespace""" mod = import_module(module_name) klass = getattr(mod, class_name) return klass @staticmethod def _encode_numpy(obj): def _to_dict(item): if isinstance(item, np.ndarray): return { "__ndarray__": item.tolist(), "__dtype__": str(item.dtype), "__shape__": item.shape, } else: return np.asscalar(item) def _is_numpy(item): return type(item).__module__ == np.__name__ if isinstance(obj, dict): obj = obj.copy() iterator = obj.items() elif isinstance(obj, list): obj = obj.copy() iterator = enumerate(obj) else: return obj for key, value in iterator: if _is_numpy(value): obj[key] = _to_dict(value) elif isinstance(value, (list, dict)): obj[key] = RetrievalProduct._encode_numpy(value) return obj @staticmethod def _decode_numpy(obj): def _from_dict(item): try: return np.array( item["__ndarray__"], dtype=item["__dtype__"], ) except TypeError: return np.array( item["__ndarray__"], dtype=literal_eval(item["__dtype__"]), ) def _is_numpy(item): return isinstance(item, dict) and "__ndarray__" in item if isinstance(obj, dict): obj = obj.copy() iterator = obj.items() elif isinstance(obj, list): obj = obj.copy() iterator = enumerate(obj) else: return obj for key, value in iterator: if _is_numpy(value): obj[key] = _from_dict(value) elif isinstance(value, (list, tuple, dict)): obj[key] = RetrievalProduct._decode_numpy(value) return obj @staticmethod def _tree_to_dict(tree): return { "module": type(tree).__module__, "class": type(tree).__name__, "coefs": tree.__getstate__(), } @staticmethod def _tree_from_dict(dictionary, coefs): instance = RetrievalProduct._import_class( dictionary["module"], dictionary["class"] ) tree = instance( to_array(coefs["n_features_"]), to_array(coefs["n_classes_"]), to_array(coefs["n_outputs_"]) ) tree.__setstate__(dictionary["coefs"]) return tree @staticmethod def _model_to_dict(model): """Convert a sklearn model object to a dictionary""" dictionary = { "module": type(model).__module__, "class": type(model).__name__, "params": model.get_params(deep=True), "coefs": { attr: copy.deepcopy(getattr(model, attr)) for attr in model.__dir__() if not attr.startswith("__") and attr.endswith("_") } } if "tree_" in dictionary["coefs"]: # Not funny. sklearn.tree objects are not directly # serializable to json. Hence, we must dump them by ourselves. dictionary["coefs"]["tree_"] = RetrievalProduct._tree_to_dict( dictionary["coefs"]["tree_"] ) return RetrievalProduct._encode_numpy(dictionary) @staticmethod def _model_from_dict(dictionary): """Create a sklearn model object from a dictionary""" dictionary = RetrievalProduct._decode_numpy(dictionary) instance = RetrievalProduct._import_class( dictionary["module"], dictionary["class"] ) model = instance(**dictionary["params"]) for attr, value in dictionary["coefs"].items(): if attr == "tree_": # We must treat a tree specially: value = RetrievalProduct._tree_from_dict( value, dictionary["coefs"] ) try: setattr(model, attr, value) except AttributeError: # Some attributes cannot be set such as feature_importances_ pass return model @staticmethod def _pipeline_to_dict(pipeline): """Convert a pipeline object to a dictionary""" if pipeline is None: raise ValueError("No object trained!") all_steps = {} for name, model in pipeline.steps: all_steps[name] = RetrievalProduct._model_to_dict(model) return all_steps @staticmethod def _pipeline_from_dict(dictionary): """Create a pipeline object from a dictionary""" all_steps = [] for name, step in dictionary.items(): model = RetrievalProduct._model_from_dict(step) all_steps.append([name, model]) return Pipeline(all_steps) def is_trained(self): """Return true if RetrievalProduct is trained""" return self.estimator is not None @classmethod def from_dict(cls, parameter, *args, **kwargs): """Load a retrieval product from a dictionary Args: parameter: A dictionary with the training parameters. Simply the output of :meth:`to_dict`. *args: Positional arguments allowed for :meth:`__init__`. **kwargs Keyword arguments allowed for :meth:`__init__`. Returns: A new :class:`RetrievalProduct` object. """ self = cls(*args, **kwargs) estimator = parameter.get("estimator", None) if estimator is None: raise ValueError("Found no coefficients for estimator!") is_pipeline = parameter["estimator_is_pipeline"] if is_pipeline: self.estimator = self._pipeline_from_dict(estimator) else: self.estimator = self._model_from_dict(estimator) self._inputs = parameter["inputs"] self._outputs = parameter["outputs"] return self def to_dict(self): """Dump this retrieval product to a dictionary""" parameter = {} if isinstance(self.estimator, Pipeline): parameter["estimator"] = self._pipeline_to_dict(self.estimator) parameter["estimator_is_pipeline"] = True else: parameter["estimator"] = self._model_to_dict(self.estimator) parameter["estimator_is_pipeline"] = False parameter["inputs"] = self.inputs parameter["outputs"] = self.outputs return parameter @classmethod def from_txt(cls, filename, *args, **kwargs): """Load a retrieval product from a txt file Notes: The output format is not standard json! Training parameters are: * weights of the estimator * names of the input and target fields Args: filename: The name of file from where to load the training parameters. *args: Positional arguments allowed for :meth:`__init__`. **kwargs Keyword arguments allowed for :meth:`__init__`. Returns: A new :class:`RetrievalProduct` object. """ with open(filename, 'r') as infile: parameter = literal_eval(infile.read()) return cls.from_dict(parameter, *args, **kwargs) def to_txt(self, filename): """Save this retrieval product to a txt file Training parameters are: * configuration of the used estimator * names of the input, output, and target fields Args: filename: The name of the file where to store the training parameters. Returns: None """ with open(filename, 'w') as outfile: outfile.write(repr(self.to_dict())) def retrieve(self, inputs): """Predict the target values for data coming from arrays Args: inputs: A pandas.DataFrame object. The keys must be the same labels as used in :meth:`train`. Returns: A pandas.DataFrame object with the retrieved data. Examples: .. :code-block:: python # TODO """ if self.estimator is None: raise NotTrainedError() # Skip empty datasets if inputs.empty: return None # Retrieve the data from the neural network: output_data = self.estimator.predict(inputs) return pd.DataFrame(data=output_data, columns=self.outputs) def score(self, inputs, targets): """ Args: inputs: A pandas.DataFrame with input data. targets: A pandas.DataFrame with target data. Returns: The metric score as a number """ if self.estimator is None: raise NotTrainedError() return self.estimator.score(inputs.squeeze(), targets.squeeze()) def train(self, estimator, inputs, targets): """Train this retriever with data from arrays Args: estimator: The object that will be trained. If it is a trainer object such as a GridSearchCV, the best estimator will be chosen after training. Can also be a Pipeline or a standard Estimator from scikit-learn. inputs: A pandas.DataFrame with input data. targets: A pandas.DataFrame with target data. Returns: A float number indicating the training score. """ # The input and target labels will be saved because to know what this # product retrieves and from what: self._inputs = inputs.columns.tolist() self._outputs = targets.columns.tolist() # Start to train! estimator.fit(inputs.squeeze(), targets.squeeze()) # Let's check whether the estimator was a trainer object such as # GridSearchCV, etc. Then we save only the best estimator. if hasattr(estimator, "best_estimator_"): # Use the best estimator from now on: self.estimator = estimator.best_estimator_ else: self.estimator = estimator return self.score(inputs, targets)

f72f3b30d80ddaeb33b04d28e7f95a0cabbea8cd

py

Python

integrations/tensorflow/e2e/broadcasting_test.py

BernhardRiemann/iree

471349762b316f7d6b83eb5f9089255d78052758

2021-03-15T13:53:30.000Z

2021-03-15T13:53:30.000Z

integrations/tensorflow/e2e/broadcasting_test.py

BernhardRiemann/iree

471349762b316f7d6b83eb5f9089255d78052758

integrations/tensorflow/e2e/broadcasting_test.py

BernhardRiemann/iree

471349762b316f7d6b83eb5f9089255d78052758

# Lint as: python3 # Copyright 2020 Google LLC # # 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 # # https://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. """Test broadcasting support.""" from absl import app import numpy as np from pyiree.tf.support import tf_test_utils from pyiree.tf.support import tf_utils import tensorflow.compat.v2 as tf class BroadcastingModule(tf.Module): @tf.function(input_signature=[ tf.TensorSpec([None], tf.float32), tf.TensorSpec([None], tf.float32), ]) def add(self, lhs, rhs): return lhs + rhs class BroadcastingTest(tf_test_utils.TracedModuleTestCase): def __init__(self, methodName="runTest"): super(BroadcastingTest, self).__init__(methodName) self._modules = tf_test_utils.compile_tf_module(BroadcastingModule) def test_add_same_shape(self): def add_same_shape(module): lhs = tf_utils.uniform([4]) rhs = tf_utils.uniform([4]) module.add(lhs, rhs) self.compare_backends(add_same_shape, self._modules) def test_add_broadcast_lhs(self): def add_broadcast_lhs(module): lhs = tf_utils.uniform([1]) rhs = tf_utils.uniform([4]) module.add(lhs, rhs) self.compare_backends(add_broadcast_lhs, self._modules) def test_add_broadcast_rhs(self): def add_broadcast_rhs(module): lhs = tf_utils.uniform([4]) rhs = tf_utils.uniform([1]) module.add(lhs, rhs) self.compare_backends(add_broadcast_rhs, self._modules) def main(argv): del argv # Unused if hasattr(tf, 'enable_v2_behavior'): tf.enable_v2_behavior() tf.test.main() if __name__ == '__main__': app.run(main)

f72f41e99b9e572abeb953f1f643d46f46a98281

py

Python

ros2_ws/src/utils/logger/logger/logger.py

FastSense/rosbot-ros2

c2d274ce179534fec5b2786a6f96b6d638019ac4

ros2_ws/src/utils/logger/logger/logger.py

FastSense/rosbot-ros2

c2d274ce179534fec5b2786a6f96b6d638019ac4

2021-07-05T14:50:09.000Z

2021-09-14T15:21:11.000Z

ros2_ws/src/utils/logger/logger/logger.py

FastSense/metalbot

063c897a16129d9aa88c2c7c52bdf6547af894e4

import os import pandas as pd from matplotlib import pyplot as plt import rclpy import numpy as np from rclpy.node import Node from geometry_msgs.msg import Twist from nav_msgs.msg import Odometry from std_srvs.srv import Empty from logger.utils import convert_ros2_time_to_float from logger.create_graphs import build_general_graph_for_rosbot from scipy.spatial.transform import Rotation class Logger(Node): """ Class for logging the state of the rosbot Node for logging the state of the robot, kinematic model (optional) and neural network model (optional), control and time stamps :Attributes: :first_tick: (bool) srue if it is first callbcak :init_time: (float) node start time (time of the first callback) :curr_control: (list) current control [u_v, u_w] :output_path: (str) Absolute path to the directory where the logged data will be saved :control_topic: (str) nam of the control topic (/cmd_vel) :parent_frame: (str) name of the origin tf frame :kinetic_model_frame: (str) name of the kinematic model tf frame :nn_model_frame: (str) name of the NN model tf frame :robot_state: (pandas.DataFrame) container for rosbot state :kinetic_model_state: (pandas.DataFrame) container for kinematic model state :nn_model_state: (pandas.DataFrame) container for NN model state :robot_control: (pandas.DataFrame) container for rosbot control :time: (list) container for time stamps :odom_sub: subscriber to /odom topic :control_sub: subscriber to control topic """ def __init__(self): """ """ super().__init__('logger') self.init_parameters() self.get_node_parametes() self.init_subs() self.init_containers() self.first_tick = True self.init_time = None self.curr_control = list() self.srv = self.create_service(Empty, 'shutdown_logger', self.shutdown_logger_callback) rclpy.get_default_context().on_shutdown(self.on_shutdown) def init_parameters(self): """ Declares node parameters """ self.declare_parameter('output_path', "") self.declare_parameter('control_topic', '/cmd_vel') self.declare_parameter('parent_frame', 'odom') self.declare_parameter('kinetic_model_frame', 'model_link') self.declare_parameter('nn_model_frame', 'nn_model_link') # self.declare_parameter('tf_topic', '/tf') def get_node_parametes(self): """ Gets node parameters """ self.output_path = self.get_parameter('output_path').get_parameter_value().string_value self.control_topic = self.get_parameter('control_topic').get_parameter_value().string_value self.parent_frame = self.get_parameter('parent_frame').get_parameter_value().string_value self.kinetic_model_frame = self.get_parameter('kinetic_model_frame').get_parameter_value().string_value self.nn_model_frame = self.get_parameter('nn_model_frame').get_parameter_value().string_value # self.tf_topic = self.get_parameter('tf_topic').get_parameter_value().string_value def init_containers(self): """ Declares containers for logged data """ self.robot_state = pd.DataFrame( columns=[ 'x', 'y', 'z', 'roll', 'pitch', 'yaw', 'v_x', 'v_y', 'v_z', 'w_x', 'w_y', 'w_z', ] ) self.kinetic_model_state = pd.DataFrame( columns=[ 'x', 'y', 'z', 'roll', 'pitch', 'yaw', 'v_x', 'v_y', 'v_z', 'w_x', 'w_y', 'w_z', ] ) self.nn_model_state = pd.DataFrame( columns=[ 'x', 'y', 'z', 'roll', 'pitch', 'yaw', 'v_x', 'v_y', 'v_z', 'w_x', 'w_y', 'w_z', ] ) self.robot_control = pd.DataFrame( columns=[ 'v_x', 'w_z' ] ) self.time = list() def init_subs(self): """ Declares node subscribers """ self.odom_sub = self.create_subscription( Odometry, '/odom', self.odom_callback, 1 ) self.control_sub = self.create_subscription( Twist, self.control_topic, self.control_callback, 1 ) # prevent unused variable warning self.control_sub self.odom_sub def odom_callback(self, odom_msg): """ Callback on odom message Robot position, current time and control are logged Args: :odom_msg: (nav_msgs.msg.Odometry): odom msg """ if (len(self.curr_control) == 0): return curr_time = convert_ros2_time_to_float( self.get_clock().now().seconds_nanoseconds() ) # update time container self.time.append(curr_time - self.init_time) # update control container self.robot_control.loc[len(self.robot_control)] = self.curr_control # update robot_state container rosbot_pose = odom_msg.pose.pose rosbot_velocities = odom_msg.twist.twist x, y, z = rosbot_pose.position.x, rosbot_pose.position.y, rosbot_pose.position.z rpy = Rotation.from_quat([ np.float(rosbot_pose.orientation.x), np.float(rosbot_pose.orientation.y), np.float(rosbot_pose.orientation.z), np.float(rosbot_pose.orientation.w)] ).as_euler('xyz') rpy = list(rpy) v_x = rosbot_velocities.linear.x # Linear velocity v_y = rosbot_velocities.linear.y v_z = rosbot_velocities.linear.z w_x = rosbot_velocities.angular.x w_y = rosbot_velocities.angular.y w_z = rosbot_velocities.angular.z # YAW velocity last_row = len(self.robot_state) self.robot_state.loc[last_row] = [x,y,z] + rpy + [v_x, v_y, v_z, w_x, w_y, w_z] def control_callback(self, control): """ Updates the current control Args: :control: (geometry_msgs.msg.Twist) control msg """ if self.first_tick: self.first_tick = False self.init_time = convert_ros2_time_to_float( self.get_clock().now().seconds_nanoseconds() ) self.curr_control = [control.linear.x, control.angular.z] def save_collected_data_to_csv(self): """ Saves logged data in csv format """ # if not os.path.exists(self.output_path): # os.makedirs(self.output_path) self.robot_state.to_csv( path_or_buf=os.path.join(self.output_path, "rosbot_state.csv"), sep=' ', index=False ) self.kinetic_model_state.to_csv( path_or_buf=os.path.join(self.output_path, "kinematic_model_state.csv"), sep=' ', index=False ) self.nn_model_state.to_csv( path_or_buf=os.path.join(self.output_path, "nn_model_state.csv"), sep=' ', index=False ) self.robot_control.to_csv( path_or_buf= os.path.join(self.output_path,"control.csv"), sep=' ', index=False ) pd.DataFrame(data=self.time, columns=['t']).to_csv( path_or_buf= os.path.join(self.output_path, "time.csv"), sep=' ', index=False ) def shutdown_logger_callback(self): """ Callback for the shutdown_logger service, turns off the logger node """ rclpy.try_shutdown() def on_shutdown(self): """ A function that is executed when a node shutdown. Plots a graph of all collected data, saves it in csv format. """ if not os.path.exists(self.output_path): os.makedirs(self.output_path) data_plots = build_general_graph_for_rosbot( robot_state_df=self.robot_state, control_df=self.robot_control, time_list=self.time, save_to_png=True, path=self.output_path ) self.save_collected_data_to_csv() self.get_logger().warn("Output path = {}".format(self.output_path)) def main(): """ Declares the logger node. Node works """ rclpy.init() logger = Logger() try: rclpy.spin(logger) except: pass logger.destroy_node() rclpy.shutdown() if __name__ == '__main__': main()

f72f4aa4e427e9d3ee2d0c986960f64ae8d9cdb5

py

Python

pyfatfs/__init__.py

abrasive/pyfatfs

a35586bfa2b1d3f8d4638142407db68f9318b86d

pyfatfs/__init__.py

abrasive/pyfatfs

a35586bfa2b1d3f8d4638142407db68f9318b86d

pyfatfs/__init__.py

abrasive/pyfatfs

a35586bfa2b1d3f8d4638142407db68f9318b86d

# -*- coding: utf-8 -*- """ Python FAT filesystem module with :doc:`PyFilesystem2 <pyfilesystem2:index>` \ compatibility. pyfatfs allows interaction with FAT12/16/32 filesystems, either via :doc:`PyFilesystem2 <pyfilesystem2:index>` for file-level abstraction or direct interaction with the filesystem for low-level access. """ __name__ = 'pyfatfs' __author__ = 'Nathan-J. Hirschauer' __author_email__ = 'nathanhi@deepserve.info' __license__ = 'MIT License' #: Specifies default ("OEM") encoding from pyfatfs._exceptions import PyFATException FAT_OEM_ENCODING = 'ibm437' #: Specifies the long file name encoding, which is always UTF-16 (LE) FAT_LFN_ENCODING = 'utf-16-le' def _init_check(func): def _wrapper(*args, **kwargs): initialized = args[0].initialized if initialized is True: return func(*args, **kwargs) else: raise PyFATException("Class has not yet been fully initialized, " "please instantiate first.") return _wrapper

f72f5ff661ebbd7baa4fdc30f0fe55a852bc6baf

py

Python

pycondor/geodesic_test_proj.py

kant/pycondor

ee87854504e8f4023feda860d8a9ddbecc7a70da

2015-04-17T08:25:30.000Z

2020-04-11T23:58:16.000Z

pycondor/geodesic_test_proj.py

kant/pycondor

ee87854504e8f4023feda860d8a9ddbecc7a70da

2015-12-22T07:40:02.000Z

2019-01-21T15:07:00.000Z

pycondor/geodesic_test_proj.py

kant/pycondor

ee87854504e8f4023feda860d8a9ddbecc7a70da

2015-11-13T18:55:22.000Z

2020-03-12T19:32:56.000Z

#!/usr/bin/env python #-*- coding:utf-8 -*- import click import os #import json import pandas as pd import numpy as np import pyproj import matplotlib.pyplot as plt from geodesic import plot_geodesic @click.command() @click.argument('xls_filename') @click.option('--outdir', default='', help="Output directory - default is 'script_directory\out'") def main(xls_filename, outdir): basepath = os.path.dirname(__file__) #basepath = os.path.dirname(os.path.abspath(__file__)) if outdir=='': outdir = os.path.join(basepath, 'out') #xls_filename = os.path.join(outdir, "Provence-Oisans2.xlsx") filename_base, filename_ext = os.path.splitext(os.path.basename(xls_filename)) d_df = {} d_df = pd.read_excel(xls_filename, sheetname=None) max_x, max_y = d_df['ref']['PosX'].max(), d_df['ref']['PosY'].max() print "max_x=%s, max_y=%s" % (max_x, max_y) p = pyproj.Proj( proj='utm', zone=32, ellps='WGS84' ) d_df['measures']['PosX2'] = np.nan d_df['measures']['PosY2'] = np.nan for i, point in d_df['measures'].iterrows(): xy2 = p(point['Lat'], point['Lon']) d_df['measures']['PosX2'][i] = xy2[0] d_df['measures']['PosY2'][i] = xy2[1] #print(xy2) d_df['measures']['Eps'] = np.sqrt( (d_df['measures']['PosX2'] - d_df['measures']['PosX'])**2 + \ (d_df['measures']['PosY2'] - d_df['measures']['PosY'])**2 ) print(d_df) print(d_df['measures']['Eps'].mean()) plot_geodesic(outdir, filename_base, d_df['measures']) plt.show() #if show: # plt.show() if __name__ == "__main__": main()

f72f76abe1221bf6bd92370f84f0906ef075e999

py

Python

src/dataset_builder.py

elangovana/large-scale-ptm-ppi

cc835df915d12dd20c35f9cea5e40365200a6d3d

2022-02-25T22:06:39.000Z

2022-02-25T22:06:39.000Z

src/dataset_builder.py

elangovana/ppi-aimed

cc835df915d12dd20c35f9cea5e40365200a6d3d

src/dataset_builder.py

elangovana/ppi-aimed

cc835df915d12dd20c35f9cea5e40365200a6d3d

import logging import os from torch.utils.data import DataLoader from locator import Locator class DatasetBuilder: def __init__(self, val_data, dataset_factory_name, tokenisor_factory_name, train_data=None, num_workers=None, batch_size=8, addition_args_dict=None): self._addition_args_dict = addition_args_dict self.train_data = train_data self.val_data = val_data self.batch_size = batch_size self._dataset_factory = Locator().get(dataset_factory_name) self._tokenisor_factory = Locator().get(tokenisor_factory_name) self.num_workers = num_workers or os.cpu_count() - 1 if self.num_workers <= 0: self.num_workers = 0 self._tokenisor = None self._train_dataloader = None self._train_dataset = None self._val_dataset = None self._val_dataloader = None self._scorers = None self._label_mapper = None @property def _logger(self): return logging.getLogger(__name__) def get_tokenisor(self): self._logger.info("Retrieving Tokeniser") if self._tokenisor is None: self._tokenisor = self._tokenisor_factory.get_tokenisor(**self._addition_args_dict) return self._tokenisor def get_train_dataset(self): if self._train_dataset is None: self._train_dataset = self._dataset_factory.get_dataset(self.train_data, preprocessors=self.get_tokenisor(), **self._addition_args_dict) return self._train_dataset def get_val_dataset(self): if self._val_dataset is None: self._val_dataset = self._dataset_factory.get_dataset(self.val_data, preprocessors=self.get_tokenisor(), **self._addition_args_dict) return self._val_dataset def get_label_mapper(self): if self._label_mapper is None: self._label_mapper = self._dataset_factory.get_label_mapper() return self._label_mapper def num_classes(self): return self.get_label_mapper().num_classes def positive_label_index(self): return self._label_mapper.positive_label_index def get_scorers(self): if self._scorers is None: self._scorers = self._dataset_factory.get_scorers() return self._scorers def get_train_dataloader(self): if self._train_dataloader is None: self._train_dataloader = DataLoader(dataset=self.get_train_dataset(), num_workers=self.num_workers, batch_size=self.batch_size, shuffle=True) return self._train_dataloader def get_val_dataloader(self): if self._val_dataloader is None: self._val_dataloader = DataLoader(dataset=self.get_val_dataset(), num_workers=self.num_workers, batch_size=self.batch_size, shuffle=False) return self._val_dataloader

f72f8d11340df1f1d9eb56840c1b60800b76a5a8

py

Python

Calculator.py

EdvinAlvarado/Code-Wars

a3a06a44cda004052b5c0930f3693678c5c92e21

Calculator.py

EdvinAlvarado/Code-Wars

a3a06a44cda004052b5c0930f3693678c5c92e21

Calculator.py

EdvinAlvarado/Code-Wars

a3a06a44cda004052b5c0930f3693678c5c92e21

class Calculator(object): def evaluate(self, string): print(string) cmd = [int(s) if s.isdigit() else s for s in string.split(" ")] cmd = [float(s) if isinstance(s, str) and s.find('.') != -1 else s for s in cmd] print(cmd) for i in range(sum([1 if s == '*' or s == '/' else 0 for s in cmd])): for i, p in enumerate(cmd): if p == '*': cmd[i - 1] = cmd[i - 1] * cmd[i + 1] del cmd[i:i+2] break elif p == '/': cmd[i - 1] = cmd[i - 1] / cmd[i + 1] del cmd[i:i+2] break for i in range(sum([1 if s == '+' or s == '-' else 0 for s in cmd])): for i, p in enumerate(cmd): if p == '+': cmd[i - 1] = cmd[i - 1] + cmd[i + 1] del cmd[i:i+2] break elif p == '-': cmd[i - 1] = cmd[i - 1] - cmd[i + 1] del cmd[i:i+2] break return cmd[0]

f72f8e94a0df815f7d517e2b81ffc86c5c545f07

py

Python

tensorflow/contrib/autograph/utils/multiple_dispatch_test.py

tianyapiaozi/tensorflow

fb3ce0467766a8e91f1da0ad7ada7c24fde7a73a

2017-05-25T16:02:15.000Z

2021-06-09T16:08:08.000Z

tensorflow/contrib/autograph/utils/multiple_dispatch_test.py

shrikunjsarda/tensorflow

7e8927e7af0c51ac20a63bd4eab6ff83df1a39ae

2017-04-26T16:49:49.000Z

2019-10-15T11:39:26.000Z

tensorflow/contrib/autograph/utils/multiple_dispatch_test.py

shrikunjsarda/tensorflow

7e8927e7af0c51ac20a63bd4eab6ff83df1a39ae

2018-09-11T02:17:17.000Z

2021-12-15T10:33:35.000Z

# Copyright 2017 The TensorFlow Authors. 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. # ============================================================================== """Tests for multiple_dispatch.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from tensorflow.contrib.autograph.utils import multiple_dispatch from tensorflow.python.client.session import Session from tensorflow.python.framework.constant_op import constant from tensorflow.python.platform import test class MultipleDispatchTest(test.TestCase): def test_dynamic_is_python(self): a = np.eye(3) also_a = a not_actually_a = np.eye(3) should_be_true1 = multiple_dispatch.dynamic_is(a, also_a) should_be_false1 = multiple_dispatch.dynamic_is_not(a, also_a) should_be_true2 = multiple_dispatch.dynamic_is_not(a, not_actually_a) should_be_false2 = multiple_dispatch.dynamic_is(a, not_actually_a) self.assertTrue(should_be_true1) self.assertTrue(should_be_true2) self.assertFalse(should_be_false1) self.assertFalse(should_be_false2) def test_dynamic_is_tf(self): with Session().as_default(): a = constant([2.0]) also_a = a not_actually_a = constant([2.0]) should_be_true1 = multiple_dispatch.dynamic_is(a, also_a) should_be_false1 = multiple_dispatch.dynamic_is_not(a, also_a) should_be_true2 = multiple_dispatch.dynamic_is_not(a, not_actually_a) should_be_false2 = multiple_dispatch.dynamic_is(a, not_actually_a) self.assertTrue(should_be_true1) self.assertTrue(should_be_true2) self.assertFalse(should_be_false1) self.assertFalse(should_be_false2) def test_run_cond_python(self): true_fn = lambda: (2,) false_fn = lambda: (3,) self.assertEqual(multiple_dispatch.run_cond(True, true_fn, false_fn), 2) self.assertEqual(multiple_dispatch.run_cond(False, true_fn, false_fn), 3) def test_run_cond_tf(self): true_fn = lambda: (constant(2),) false_fn = lambda: (constant(3),) with Session() as sess: out = multiple_dispatch.run_cond(constant(True), true_fn, false_fn) self.assertEqual(sess.run(out), 2) out = multiple_dispatch.run_cond(constant(False), true_fn, false_fn) self.assertEqual(sess.run(out), 3) if __name__ == '__main__': test.main()

f72fa31aa61c2010032ba331da9c46f0c28c8f64

py

Python

recipys/types.py

gmso/recipys

8ca39a7b0ace2c678fe7a5c8271c6843db6c2c35

2021-07-24T20:49:35.000Z

2021-08-21T18:15:16.000Z

recipys/types.py

gmso/recipys

8ca39a7b0ace2c678fe7a5c8271c6843db6c2c35

2021-08-17T17:11:09.000Z

2021-09-01T19:05:17.000Z

recipys/types.py

gmso/recipys

8ca39a7b0ace2c678fe7a5c8271c6843db6c2c35

2021-07-29T16:36:35.000Z

2021-07-29T16:36:35.000Z

from dataclasses import dataclass from typing import Optional, List @dataclass class RecipeConstraints: meal: Optional[str] = None ingredients: Optional[List[str]] = None @dataclass class Printable: title: str = "" ingredients: str = "" preparation: str = "" error_message: Optional[str] = None warning_message: Optional[str] = None info_message: Optional[str] = None @dataclass class FetchingError(Exception): message: str = "An error ocurred" @dataclass class PrintInterrupt(Exception): printable: Printable

f72fac17ae338185f2e1470376f1a6802595e44a

py

Python

jnpy/app/vnpy_webtrader/__init__.py

jojoquant/jonpy

58692f8fbf398aab7be915a63d0a376e2e0e664c

2020-05-19T07:32:39.000Z

2022-03-14T09:09:48.000Z

jnpy/app/vnpy_webtrader/__init__.py

jojoquant/jonpy

58692f8fbf398aab7be915a63d0a376e2e0e664c

jnpy/app/vnpy_webtrader/__init__.py

jojoquant/jonpy

58692f8fbf398aab7be915a63d0a376e2e0e664c

2020-04-02T08:30:17.000Z

2020-05-03T12:12:05.000Z

# The MIT License (MIT) # # Copyright (c) 2015-present, Xiaoyou Chen # # 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 pathlib import Path from vnpy.trader.app import BaseApp from .engine import WebEngine, APP_NAME class WebTraderApp(BaseApp): """""" app_name = APP_NAME app_module = __module__ app_path = Path(__file__).parent display_name = "Web服务" engine_class = WebEngine widget_name = "WebManager" icon_name = "web.ico"

f72fb1455f5a6d221b2e71016d342136e0b43efe

py

Python

instance/config.py

ags68/CS4398Project

a9652a3670fdbfd2f482104b77573a2d1f138c69

2017-02-27T02:13:52.000Z

2017-03-05T03:54:25.000Z

instance/config.py

ags68/CS4398Project

a9652a3670fdbfd2f482104b77573a2d1f138c69

instance/config.py

ags68/CS4398Project

a9652a3670fdbfd2f482104b77573a2d1f138c69

# instance/config.py SECRET_KEY = 'p9Bv<3Eid9%$i01' SQLALCHEMY_DATABASE_URI = 'mysql://esss_admin:esss2017@localhost/esss_db'

f72fbfc6053fee1b605915399588d9a35599ebe1

py

Python

care/utils/tests/test_base.py

agzuniverse/care

952babf5b394921fcdb4fd4b1405cb571261f322

care/utils/tests/test_base.py

agzuniverse/care

952babf5b394921fcdb4fd4b1405cb571261f322

care/utils/tests/test_base.py

agzuniverse/care

952babf5b394921fcdb4fd4b1405cb571261f322

import abc import datetime from collections import OrderedDict from typing import Any, Dict import dateparser from django.contrib.gis.geos import Point from pytz import unicode from rest_framework import status from rest_framework.test import APITestCase from care.facility.models import ( CATEGORY_CHOICES, DISEASE_CHOICES_MAP, SYMPTOM_CHOICES, Disease, DiseaseStatusEnum, Facility, LocalBody, PatientConsultation, PatientRegistration, User, ) from care.users.models import District, State from config.tests.helper import EverythingEquals, mock_equal class TestBase(APITestCase): """ Base class for tests, handles most of the test setup and tools for setting up data """ maxDiff = None @classmethod def create_user(cls, district: District, username: str = "user", **kwargs): data = { "email": f"{username}@somedomain.com", "phone_number": "5554446667", "age": 30, "gender": 2, "verified": True, "username": username, "password": "bar", "district": district, "user_type": User.TYPE_VALUE_MAP["Staff"], } data.update(kwargs) return User.objects.create_user(**data) @classmethod def create_super_user(cls, district: District, username: str = "superuser"): user = cls.create_user(district=district, username=username, user_type=User.TYPE_VALUE_MAP["DistrictAdmin"],) user.is_superuser = True user.save() return user @classmethod def create_district(cls, state: State): return District.objects.create(state=state, name=f"District{datetime.datetime.now().timestamp()}") @classmethod def create_state(cls): return State.objects.create(name=f"State{datetime.datetime.now().timestamp()}") @classmethod def create_facility(cls, district: District, user: User = None, **kwargs): user = user or cls.user data = { "name": "Foo", "district": district, "facility_type": 1, "address": "8/88, 1st Cross, 1st Main, Boo Layout", "location": Point(24.452545, 49.878248), "oxygen_capacity": 10, "phone_number": "9998887776", "created_by": user, } data.update(kwargs) f = Facility(**data) f.save() return f @classmethod def create_patient(cls, **kwargs): patient_data = cls.get_patient_data().copy() patient_data.update(kwargs) medical_history = patient_data.pop("medical_history", []) district_id = patient_data.pop("district", None) state_id = patient_data.pop("state", None) patient_data.update( { "district_id": district_id, "state_id": state_id, "disease_status": getattr(DiseaseStatusEnum, patient_data["disease_status"]).value, } ) patient = PatientRegistration.objects.create(**patient_data) diseases = [ Disease.objects.create(patient=patient, disease=DISEASE_CHOICES_MAP[mh["disease"]], details=mh["details"]) for mh in medical_history ] patient.medical_history.set(diseases) return patient @classmethod def get_user_data(cls, district: District = None, user_type: str = None): """ Returns the data to be used for API testing Returns: dict Params: district: District user_type: str(A valid mapping for the integer types mentioned inside the models) """ district = district or cls.district user_type = user_type or User.TYPE_VALUE_MAP["Staff"] return { "user_type": user_type, "district": district, "state": district.state, "phone_number": "8887776665", "gender": 2, "age": 30, "email": "foo@foobar.com", "username": "user", "password": "bar", } @classmethod def get_facility_data(cls, district): """ Returns the data to be used for API testing Returns: dict Params: district: int An id for the instance of District object created user_type: str A valid mapping for the integer types mentioned inside the models """ return { "name": "Foo", "district": (district or cls.district).id, "facility_type": 1, "address": f"Address {datetime.datetime.now().timestamp}", "location": {"latitude": 49.878248, "longitude": 24.452545}, "oxygen_capacity": 10, "phone_number": "9998887776", "capacity": [], } @classmethod def get_patient_data(cls, district=None, state=None): return { "name": "Foo", "age": 32, "date_of_birth": datetime.date(1992, 4, 1), "gender": 2, "is_medical_worker": True, "blood_group": "O+", "ongoing_medication": "", "date_of_return": datetime.datetime(2020, 4, 1, 15, 30, 00), "disease_status": "SUSPECTED", "phone_number": "+918888888888", "address": "Global citizen", "contact_with_confirmed_carrier": True, "contact_with_suspected_carrier": True, "estimated_contact_date": None, "past_travel": False, "countries_travelled": "", "present_health": "Fine", "has_SARI": False, "is_active": True, "state": (state or cls.state).id, "district": (district or cls.district).id, "local_body": None, "number_of_aged_dependents": 2, "number_of_chronic_diseased_dependents": 1, "medical_history": [{"disease": "Diabetes", "details": "150 count"}], "date_of_receipt_of_information": datetime.datetime(2020, 4, 1, 15, 30, 00), } @classmethod def setUpClass(cls) -> None: super(TestBase, cls).setUpClass() cls.state = cls.create_state() cls.district = cls.create_district(cls.state) cls.user_type = User.TYPE_VALUE_MAP["Staff"] cls.user = cls.create_user(cls.district) cls.super_user = cls.create_super_user(district=cls.district) cls.facility = cls.create_facility(cls.district) cls.patient = cls.create_patient() cls.user_data = cls.get_user_data(cls.district, cls.user_type) cls.facility_data = cls.get_facility_data(cls.district) cls.patient_data = cls.get_patient_data(cls.district) def setUp(self) -> None: self.client.force_login(self.user) @abc.abstractmethod def get_base_url(self): """ Should return the base url of the testing viewset WITHOUT trailing slash eg: return "api/v1/facility" :return: str """ raise NotImplementedError() def get_url(self, entry_id=None, action=None, *args, **kwargs): url = self.get_base_url(*args, **kwargs) if entry_id is not None: url = f"{url}/{entry_id}" if action is not None: url = f"{url}/{action}" return f"{url}/" @classmethod def clone_object(cls, obj, save=True): new_obj = obj._meta.model.objects.get(pk=obj.id) new_obj.pk = None new_obj.id = None if save: new_obj.save() return new_obj @abc.abstractmethod def get_list_representation(self, obj) -> dict: """ Returns the dict representation of the obj in list API :param obj: Object to be represented :return: dict """ raise NotImplementedError() @abc.abstractmethod def get_detail_representation(self, obj=None) -> dict: """ Returns the dict representation of the obj in detail/retrieve API :param obj: Object to be represented :param data: data :return: dict """ raise NotImplementedError() def get_local_body_district_state_representation(self, obj): """ Returns the local body, district and state representation for the obj. The obj is expected to have `local_body`, `district` and `state` in it's attributes Eg: Facility, Patient, User :param obj: Any object which has `local_body`, `district` and `state` in attrs :return: """ response = {} response.update(self.get_local_body_representation(getattr(obj, "local_body", None))) response.update(self.get_district_representation(getattr(obj, "district", None))) response.update(self.get_state_representation(getattr(obj, "state", None))) return response def get_local_body_representation(self, local_body: LocalBody): if local_body is None: return {"local_body": None, "local_body_object": None} else: return { "local_body": local_body.id, "local_body_object": { "id": local_body.id, "name": local_body.name, "district": local_body.district.id, }, } def get_district_representation(self, district: District): if district is None: return {"district": None, "district_object": None} return { "district": district.id, "district_object": {"id": district.id, "name": district.name, "state": district.state.id,}, } def get_state_representation(self, state: State): if state is None: return {"state": None, "state_object": None} return {"state": state.id, "state_object": {"id": state.id, "name": state.name}} def assertDictEqual(self, first: Dict[Any, Any], second: Dict[Any, Any], msg: Any = ...) -> None: first_dict = self._convert_to_matchable_types(first.copy()) second_dict = self._convert_to_matchable_types(second.copy()) return super(TestBase, self).assertDictEqual(first_dict, second_dict, msg) def _convert_to_matchable_types(self, d): def dict_to_matching_type(d: dict): return {k: to_matching_type(k, v) for k, v in d.items()} def to_matching_type(name: str, value): if isinstance(value, (OrderedDict, dict)): return dict_to_matching_type(dict(value)) elif isinstance(value, list): return [to_matching_type("", v) for v in value] elif "date" in name and not isinstance(value, (type(None), EverythingEquals)): return_value = value if isinstance(value, (str, unicode,)): return_value = dateparser.parse(value) return ( return_value.astimezone(tz=datetime.timezone.utc) if isinstance(return_value, datetime.datetime) else return_value ) return value return dict_to_matching_type(d) def execute_list(self, user=None): user = user or self.user self.client.force_authenticate(user) response = self.client.get(self.get_url(), format="json") self.assertEqual(response.status_code, status.HTTP_200_OK) return response def get_facility_representation(self, facility): if facility is None: return facility else: return { "id": facility.id, "name": facility.name, "facility_type": {"id": facility.facility_type, "name": facility.get_facility_type_display()}, **self.get_local_body_district_state_representation(facility), } @classmethod def get_consultation_data(cls): return { "patient": cls.patient, "facility": cls.facility, "symptoms": [SYMPTOM_CHOICES[0][0], SYMPTOM_CHOICES[1][0]], "other_symptoms": "No other symptoms", "symptoms_onset_date": datetime.datetime(2020, 4, 7, 15, 30), "category": CATEGORY_CHOICES[0][0], "examination_details": "examination_details", "existing_medication": "existing_medication", "prescribed_medication": "prescribed_medication", "suggestion": PatientConsultation.SUGGESTION_CHOICES[0][0], "referred_to": None, "admitted": False, "admitted_to": None, "admission_date": None, "discharge_date": None, "created_date": mock_equal, "modified_date": mock_equal, } @classmethod def create_consultation(cls, patient=None, facility=None, **kwargs) -> PatientConsultation: data = cls.get_consultation_data() kwargs.update({"patient": patient or cls.patient, "facility": facility or cls.facility}) data.update(kwargs) return PatientConsultation.objects.create(**data)

f72fcde236c44645e86f524db09b26ce3bfb931b

py

Python

server/core.py

cwza/deep_t2i

22877fdd28ad407984ddc3bc4d57109c54c22fc0

server/core.py

cwza/deep_t2i

22877fdd28ad407984ddc3bc4d57109c54c22fc0

server/core.py

cwza/deep_t2i

22877fdd28ad407984ddc3bc4d57109c54c22fc0

2020-11-30T06:11:02.000Z

2020-11-30T06:11:02.000Z

import os from pathlib import Path import numpy as np from PIL import Image import requests from google.cloud import storage import base64 from io import BytesIO import uuid __all__ = ['do', 'recaptcha_check'] def predict_and2jpg(model, cap): ''' cap: "white hair yellow eyes", returns: jpeg file buffer remember to close it or use with ''' img, _ = model.predict(cap) img = Image.fromarray(np.uint8(img.numpy())) buf = BytesIO() img.save(buf, format='JPEG') buf.seek(0) return buf # import matplotlib.pyplot as plt # from deep_t2i.model_anime_heads import ExportedModel # from deep_t2i.inference_anime_heads import predict # model = ExportedModel.from_pretrained('./anime_heads.pt') # with predict_and2jpg(model, "white hair yellow eyes") as buf: # img = Image.open(buf) # plt.imshow(img) # plt.show() gs_bucket_id = os.getenv('gs_bucket_id') def upload_to_gs(client, img_file): "upload img_file to google storage name it fname and return url" bucket = client.bucket(gs_bucket_id) fname = f'{uuid.uuid4().hex[:8]}.jpg' blob = bucket.blob(fname) blob.upload_from_file(img_file, content_type="image/jpeg") return f'https://storage.googleapis.com/{gs_bucket_id}/{fname}' # from deep_t2i.model_anime_heads import ExportedModel # from deep_t2i.inference_anime_heads import predict # gs_client = storage.Client() # model = ExportedModel.from_pretrained('./anime_heads.pt') # with predict_and2jpg(model, "white hair yellow eyes") as buf: # url = upload_to_gs(gs_client, buf) # print(url) imgur_client_id = os.getenv('imgur_client_id') def upload_to_imgur(img_file): "upload img_file to imgur and return url" img = img_file.read() img = base64.standard_b64encode(img) url = "https://api.imgur.com/3/image" data = {'image': img, 'type': 'base64'} headers = { 'Authorization': f'Client-ID {imgur_client_id}' } res = requests.post(url, headers=headers, data=data).json() if res['success']: return res["data"]["link"] else: raise Exception("Failed to upload to imgur") # from deep_t2i.model_anime_heads import ExportedModel # from deep_t2i.inference_anime_heads import predict # model = ExportedModel.from_pretrained('./anime_heads.pt') # with predict_and2jpg(model, "white hair yellow eyes") as buf: # url = upload_to_imgur(buf) # print(url) def save_to_tmp(img_file): " save img_file to ./tmp_jpg/ " img = Image.open(img_file) fname = f'{uuid.uuid4().hex[:8]}.jpg' path = f'./temp_jpg/{fname}' img.save(path) return path # from deep_t2i.model_anime_heads import ExportedModel # from deep_t2i.inference_anime_heads import predict # model = ExportedModel.from_pretrained('./anime_heads.pt') # with predict_and2jpg(model, "white hair yellow eyes") as buf: # url = save_to_tmp(buf) # print(url) img_server = os.getenv("img_server") gs_client = storage.Client() if img_server=="gs" else None def do(model, cap): "generate image from model, upload image to img_server and return link" with predict_and2jpg(model, cap) as buf: if img_server=="gs": url = upload_to_gs(gs_client, buf) elif img_server=="imgur": url = upload_to_imgur(buf) else: url = save_to_tmp(buf) return url # Recaptcha check recaptcha_secret = os.getenv('recaptcha_secret') def recaptcha_check(token): if token is None: return False url = "https://www.google.com/recaptcha/api/siteverify" data = { 'secret': recaptcha_secret, 'response': token, } r = requests.post(url=url, data=data) return r.json()['success']

f7300106c5722946f16c6d7a68325a64b58c05ce

py

Python

tests/test_convention.py

henhans/TBmodels

7424acaea8d91850d80bb48898af875430f25fa0

2021-01-18T13:55:40.000Z

2021-01-18T13:55:40.000Z

tests/test_convention.py

henhans/TBmodels

7424acaea8d91850d80bb48898af875430f25fa0

tests/test_convention.py

henhans/TBmodels

7424acaea8d91850d80bb48898af875430f25fa0

#!/usr/bin/env python # -*- coding: utf-8 -*- # (c) 2015-2018, ETH Zurich, Institut fuer Theoretische Physik # Author: Dominik Gresch <greschd@gmx.ch> import numpy as np import pythtb as pt import tbmodels as tb def test_compare_pythtb(): pt_model = pt.tb_model(1, 1, lat=[[1]], orb=[[0], [0.2]]) tb_model = tb.Model(dim=1, pos=[[0], [0.2]], uc=[[1]]) pt_model.set_hop(3j, 0, 1, [1]) tb_model.add_hop(3j, 0, 1, [1]) assert np.isclose(pt_model._gen_ham([0]), tb_model.hamilton([0])).all() assert np.isclose(pt_model._gen_ham([0]), tb_model.hamilton([0], convention=1)).all() assert np.isclose(pt_model._gen_ham([1]), tb_model.hamilton([1], convention=1)).all() assert np.isclose(pt_model._gen_ham([0.2]), tb_model.hamilton(0.2, convention=1)).all()

f7300271abe53d1c530313d92118bc1bdad057e3

py

Python

ooni/report/cli.py

irl/ooni-probe

c21861c28ca6bd667715872d099006fab87222fd

ooni/report/cli.py

irl/ooni-probe

c21861c28ca6bd667715872d099006fab87222fd

ooni/report/cli.py

irl/ooni-probe

c21861c28ca6bd667715872d099006fab87222fd

from __future__ import print_function import os import sys from ooni import canonical_bouncer from ooni.report import __version__ from ooni.report import tool from ooni.settings import config from twisted.python import usage class Options(usage.Options): synopsis = """%s [options] upload | status """ % (os.path.basename(sys.argv[0]),) optFlags = [ ["default-collector", "d", "Upload the reports to the default " "collector that is looked up with the " "canonical bouncer."] ] optParameters = [ ["configfile", "f", None, "Specify the configuration file to use."], ["collector", "c", None, "Specify the collector to upload the result to."], ["bouncer", "b", None, "Specify the bouncer to query for a collector."] ] def opt_version(self): print("oonireport version: %s" % __version__) sys.exit(0) def parseArgs(self, *args): if len(args) == 0: raise usage.UsageError( "Must specify at least one command" ) return self['command'] = args[0] if self['command'] not in ("upload", "status"): raise usage.UsageError( "Must specify either command upload or status" ) if self['command'] == "upload": try: self['report_file'] = args[1] except IndexError: self['report_file'] = None def tor_check(): if not config.tor.socks_port: print("Currently oonireport requires that you start Tor yourself " "and set the socks_port inside of ooniprobe.conf") sys.exit(1) def run(): options = Options() try: options.parseOptions() except Exception as exc: print("Error: %s" % exc) print(options) sys.exit(2) config.global_options = dict(options) config.set_paths() config.read_config_file() if options['default-collector']: options['bouncer'] = canonical_bouncer if options['command'] == "upload" and options['report_file']: tor_check() return tool.upload(options['report_file'], options['collector'], options['bouncer']) elif options['command'] == "upload": tor_check() return tool.upload_all(options['collector'], options['bouncer']) elif options['command'] == "status": return tool.status() else: print(options)

f7300bb85137e40f00493456c34280037c0a2f36

py

Python

src/oscar/apps/offer/config.py

sainjusajan/django-oscar

466e8edc807be689b0a28c9e525c8323cc48b8e1

src/oscar/apps/offer/config.py

sainjusajan/django-oscar

466e8edc807be689b0a28c9e525c8323cc48b8e1

src/oscar/apps/offer/config.py

sainjusajan/django-oscar

466e8edc807be689b0a28c9e525c8323cc48b8e1

from django.apps import AppConfig from django.utils.translation import ugettext_lazy as _ class OfferConfig(AppConfig): label = 'offer' name = 'oscar.apps.offer' verbose_name = _('Offer') def ready(self): from . import signals # noqa

f7301503bf0efbff166667ede074659aa5f11e70

py

Python

Twitter/wsgi.py

sonus21/MiniTwitter

b62c0c540c1726fc7e6197b33514d7af15f1b58e

Twitter/wsgi.py

sonus21/MiniTwitter

b62c0c540c1726fc7e6197b33514d7af15f1b58e

Twitter/wsgi.py

sonus21/MiniTwitter

b62c0c540c1726fc7e6197b33514d7af15f1b58e

""" WSGI config for Twitter project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/1.9/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Twitter.settings") application = get_wsgi_application()

f7301f02b847c99bc61b46703e6c682dfcb86ed7

py

Python

bidobe/astunit.py

pbrus/binary-doppler-beaming

fb7b8e58d36da41759d643a58270a76f61bd5c90

2018-06-19T18:35:55.000Z

2018-06-19T18:35:55.000Z

bidobe/astunit.py

pbrus/binary-doppler-beaming

fb7b8e58d36da41759d643a58270a76f61bd5c90

bidobe/astunit.py

pbrus/binary-doppler-beaming

fb7b8e58d36da41759d643a58270a76f61bd5c90

""" Store physical constants and calculate astronomical units from and to the International System of Units. """ class UnitsConverter: """ UnitsConverter converts different astronomical units from and to the International System of Units (SI). """ # All constants in SI units. G = 6.67408e-11 LIGHT_SPEED = 2.99792458e8 PLANCK_CONSTANT = 6.62606979e-34 BOLTZMANN_CONSTANT = 1.38064852e-23 STEFAN_BOLTZMANN_CONSTANT = 5.670367e-8 SUN_MASS = 1.9884e30 SUN_RADIUS = 6.957e8 AU = 1.49597e11 PARSEC = 3.086e16 DAY = 86400 MINUTE = 60 def convert_sun_mass_to_kg(self, mass): """Convert mass in the solar mass to kilograms.""" return mass*self.SUN_MASS def convert_kg_to_sun_mass(self, mass): """Convert mass in kilograms to the solar mass.""" return mass/self.SUN_MASS def convert_days_to_sec(self, days): """Convert time in days to seconds.""" return days*self.DAY def convert_sec_to_days(self, seconds): """Convert time in seconds to days.""" return seconds/self.DAY def convert_min_to_sec(self, minutes): """Convert time in minutes to seconds.""" return self.MINUTE*minutes def convert_sec_to_min(self, seconds): """Convert time in seconds to minutes.""" return seconds/self.MINUTE def convert_hours_to_sec(self, minutes): """Convert time in hours to seconds.""" return (self.MINUTE**2)*minutes def convert_sec_to_hours(self, seconds): """Convert time in seconds to hours.""" return seconds/(self.MINUTE**2) def convert_au_to_m(self, au): """Convert length in the Astronomical Units to meters.""" return au*self.AU def convert_m_to_au(self, meters): """Convert length in meters to the Astronomical Units.""" return meters/self.AU def convert_kmps_to_mps(self, speed): """Convert speed in kilometers per second to meters per second.""" return 1000.0*speed def convert_mps_to_kmps(self, speed): """Convert speed in meters per second to kilometers per second.""" return speed/1000.0 def convert_m_to_sun_radius(self, meters): """Convert length in meters to the solar radius.""" return meters/self.SUN_RADIUS def convert_sun_radius_to_m(self, radii): """Convert length in the solar radius to meters.""" return self.SUN_RADIUS*radii def convert_m_to_parsec(self, meters): """Convert length in meters to parsec.""" return meters/self.PARSEC def convert_parsec_to_m(self, parsecs): """Convert length in parsec to meters.""" return parsecs*self.PARSEC

f7302747c69d4cf11b6c0eb5fdafe30a97f317af

py

Python

KoreanLipNet/training/overlapped_speakers/train.py

khujay15/koreanLipNet

9db7524c7f3a577841cff88c7cd195e941c06fd6

2020-05-19T01:47:24.000Z

2020-05-19T01:47:24.000Z

KoreanLipNet/training/overlapped_speakers/train.py

youda9/koreanLipNet

46e1304477b2bd275206559e21815d204a5d1a72

KoreanLipNet/training/overlapped_speakers/train.py

youda9/koreanLipNet

46e1304477b2bd275206559e21815d204a5d1a72

from keras.optimizers import Adam from keras.callbacks import TensorBoard, CSVLogger, ModelCheckpoint from lipnet.lipreading.generators import BasicGenerator from lipnet.lipreading.callbacks import Statistics, Visualize from lipnet.lipreading.curriculums import Curriculum from lipnet.core.decoders import Decoder from lipnet.lipreading.helpers import labels_to_text from lipnet.utils.spell import Spell from lipnet.model2 import LipNet import numpy as np import datetime import os import sys np.random.seed(55) # seed value setting CURRENT_PATH = os.path.dirname(os.path.abspath(__file__)) # train.py path PREDICT_GREEDY = False # ?? PREDICT_BEAM_WIDTH = 200 # ?? PREDICT_DICTIONARY = os.path.join(CURRENT_PATH,'..','..','common','dictionaries','grid.txt') # predict dic def curriculum_rules(epoch): return { 'sentence_length': -1, 'flip_probability': 0.5, 'jitter_probability': 0.05 } def train(run_name, speaker, start_epoch, stop_epoch, img_c, img_w, img_h, frames_n, absolute_max_string_len, minibatch_size): DATASET_DIR = os.path.join(CURRENT_PATH, speaker, 'datasets') #datasets dir path OUTPUT_DIR = os.path.join(CURRENT_PATH, speaker, 'results') #results dir path LOG_DIR = os.path.join(CURRENT_PATH, speaker, 'logs') #logs dir path curriculum = Curriculum(curriculum_rules) print "Generator start -- " lip_gen = BasicGenerator(dataset_path=DATASET_DIR, minibatch_size=minibatch_size, img_c=img_c, img_w=img_w, img_h=img_h, frames_n=frames_n, absolute_max_string_len=absolute_max_string_len, curriculum=curriculum, start_epoch=start_epoch).build() print "Generator finish --" lipnet = LipNet(img_c=img_c, img_w=img_w, img_h=img_h, frames_n=frames_n, absolute_max_string_len=absolute_max_string_len, output_size=lip_gen.get_output_size()) lipnet.summary() adam = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08) # the loss calc occurs elsewhere, so use a dummy lambda func for the loss lipnet.model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=adam) # load weight if necessary if start_epoch > 0: weight_file = os.path.join(OUTPUT_DIR, os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1))) lipnet.model.load_weights(weight_file) print "spell start--" spell = Spell(path=PREDICT_DICTIONARY) print "spell finish--" print "decoder start--" decoder = Decoder(greedy=PREDICT_GREEDY, beam_width=PREDICT_BEAM_WIDTH, postprocessors=[labels_to_text, spell.sentence]) print "decoder finish--" # define callbacks statistics = Statistics(lipnet, lip_gen.next_val(), decoder, 256, output_dir=os.path.join(OUTPUT_DIR, run_name)) visualize = Visualize(os.path.join(OUTPUT_DIR, run_name), lipnet, lip_gen.next_val(), decoder, num_display_sentences=minibatch_size) #tensorboard = TensorBoard(log_dir=os.path.join(LOG_DIR, run_name)) csv_logger = CSVLogger(os.path.join(LOG_DIR, "{}-{}.csv".format('training',run_name)), separator=',', append=True) checkpoint = ModelCheckpoint(os.path.join(OUTPUT_DIR, run_name, "weights{epoch:02d}.h5"), monitor='val_loss', save_weights_only=True, mode='auto', period=1) lipnet.model.fit_generator(generator=lip_gen.next_train(), steps_per_epoch=lip_gen.default_training_steps, epochs=stop_epoch, validation_data=lip_gen.next_val(), validation_steps=lip_gen.default_validation_steps, callbacks=[checkpoint, statistics, visualize, lip_gen, csv_logger], initial_epoch=start_epoch, verbose=1, max_q_size=5, workers=2, pickle_safe=True) if __name__ == '__main__': run_name = datetime.datetime.now().strftime('%Y:%m:%d:%H:%M:%S') # now time ex)2019:05:15:16:14:20 speaker = sys.argv[1] # speaker : s{1} train(run_name, speaker, 0, 5000, 3, 100, 50, 75, 32, 2) #5000 epoch color 100x50 75frames 32len string minibatch_size 50 # train(run_name, speaker, 0, 5000, 3, 100, 50, 75, 32, 50) #5000 epoch color 100x50 75frames 32len string minibatch_size 50

f730342ab5ef9de61150bbe987c938e724c98ab0

py

Python

taxcli/helper/invoice_files.py

Nukesor/taxcli

f313acd2f1c9a551361a535f8428a17c53e6b468

taxcli/helper/invoice_files.py

Nukesor/taxcli

f313acd2f1c9a551361a535f8428a17c53e6b468

taxcli/helper/invoice_files.py

Nukesor/taxcli

f313acd2f1c9a551361a535f8428a17c53e6b468

import os def get_invoice_files(invoices, year=False): for invoice in invoices: if invoice.invoice_file: # Get folder for this invoice and create it if it doesn't exist if not invoice.afa: folder = invoice.invoice_type.name else: folder = 'afa' if not os.path.exists(folder): os.mkdir(folder) invoice_name = '{}-{}-{}.{}'.format( invoice.contact_alias, invoice.invoice_number, invoice.date.isoformat(), invoice.invoice_file_type, ) path = os.path.join(folder, invoice_name) with open(path, "wb") as invoice_file: invoice_file.write(invoice.invoice_file)

f7307ab549cd6a961231f29a99a04cc4dd37c4f8

py

Python

StreamPy/TestExamplesListToStreams/test_example_list_multi_in_multi_out_stateful.py

AnomalyInc/StreamPy

94abca276b2857de48259f4f42ef95efbdf5f6d1

2017-04-27T11:04:27.000Z

2019-02-07T21:03:32.000Z

StreamPy/TestExamplesListToStreams/test_example_list_multi_in_multi_out_stateful.py

StreamPy/StreamPy

94abca276b2857de48259f4f42ef95efbdf5f6d1

StreamPy/TestExamplesListToStreams/test_example_list_multi_in_multi_out_stateful.py

StreamPy/StreamPy

94abca276b2857de48259f4f42ef95efbdf5f6d1

"""This module contains examples of stream_func where f_type is 'element' and stream_func has a list of multiple input streams, a single output stream, and the operation is stateless. These examples must have a LIST of input streams and not a single input stream. The functions on static Python data structures are of the form: list -> element """ if __package__ is None: import sys from os import path sys.path.append( path.dirname( path.dirname( path.abspath(__file__) ) ) ) from functools import partial from Stream import Stream, _no_value from Operators import stream_func import numpy as np from stream_test import * def inrange_and_outlier_streams(x_and_y_streams, a, b, delta): def inrange_and_outlier(x_and_y_lists, state): num_inrange, num_outliers = state z_list = zip(*x_and_y_lists) inrange_list, outliers_list = [], [] for v in z_list: if abs(a*v[0] + b -v[1]) > delta: # outlier num_outliers += 1 percentage_outliers = num_outliers/float(num_outliers+num_inrange) outliers_list.append((v, percentage_outliers)) else: # in range num_inrange += 1 percentage_outliers = num_outliers/float(num_outliers+num_inrange) inrange_list.append((v, percentage_outliers)) state = num_inrange, num_outliers return ([inrange_list, outliers_list], state) return stream_func( inputs=x_and_y_streams, f_type='list', f=inrange_and_outlier, num_outputs=2, state=(0,0)) def test(): x = Stream('input_0') y = Stream('input_1') inrange_stream, outlier_stream = inrange_and_outlier_streams( x_and_y_streams=[x,y], a=1, b=0, delta=3) inrange_stream.set_name('inrange') outlier_stream.set_name('outlier') check(inrange_stream, [((3, 4), 0.0), ((8, 8), 1.0 / 3.0), ((12, 12), 0.4)]) check(outlier_stream, [((5, 9), 0.5), ((10, 15), 0.5), ((21, 11), 0.5)]) print # Add values to the tail of stream x. x.extend([3, 5, 8, 10]) y.extend([4, 9, 8, 15]) # Print recent values of the streams print 'recent values of input streams' x.print_recent() y.print_recent() print 'recent values of output streams' inrange_stream.print_recent() outlier_stream.print_recent() print # Add more values to the tail of stream x. x.extend([12, 21, 13]) y.extend([12, 11]) # Print recent values of the streams print 'recent values of input streams' x.print_recent() y.print_recent() print 'recent values of output streams' inrange_stream.print_recent() outlier_stream.print_recent() check_empty() if __name__ == '__main__': test()

f7309bc8a28f4f8cdb7fb8535f464ad2bbe04bfe

py

Python

tests/test_invenio_circulation.py

NRodriguezcuellar/invenio-circulation

8e0c977849eb76ba9a342542dae3b6a6ef5bae16

2020-04-27T14:47:30.000Z

2020-04-27T14:47:30.000Z

tests/test_invenio_circulation.py

NRodriguezcuellar/invenio-circulation

8e0c977849eb76ba9a342542dae3b6a6ef5bae16

2020-06-09T15:23:04.000Z

2020-06-09T15:23:04.000Z

tests/test_invenio_circulation.py

NRodriguezcuellar/invenio-circulation

8e0c977849eb76ba9a342542dae3b6a6ef5bae16

2020-01-13T17:10:13.000Z

2020-01-13T17:10:13.000Z

# -*- coding: utf-8 -*- # # Copyright (C) 2018-2019 CERN. # Copyright (C) 2018-2019 RERO. # # Invenio-Circulation is free software; you can redistribute it and/or modify # it under the terms of the MIT License; see LICENSE file for more details. """Module tests.""" def test_version(): """Test version import.""" from invenio_circulation import __version__ assert __version__

f730c75227bfe93ee337638f1e0109a02d1051eb

py

Python

examples/python/01-list-properties.py

lkucalaba/tiscamera

e1fa7b21bb4dd777ae8039dfa072cfa2daa88244

2015-02-20T09:10:41.000Z

2022-03-18T08:53:26.000Z

examples/python/01-list-properties.py

lkucalaba/tiscamera

e1fa7b21bb4dd777ae8039dfa072cfa2daa88244

2015-01-19T10:18:01.000Z

2022-03-28T08:03:08.000Z

examples/python/01-list-properties.py

lkucalaba/tiscamera

e1fa7b21bb4dd777ae8039dfa072cfa2daa88244

2015-01-03T17:54:08.000Z

2022-02-09T09:55:15.000Z

#!/usr/bin/env python3 # Copyright 2017 The Imaging Source Europe GmbH # # 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. # # This example will show you how to list available properties # import sys import gi gi.require_version("Tcam", "0.1") gi.require_version("Gst", "1.0") from gi.repository import Tcam, Gst def list_properties(camera): property_names = camera.get_tcam_property_names() for name in property_names: (ret, value, min_value, max_value, default_value, step_size, value_type, flags, category, group) = camera.get_tcam_property(name) if not ret: print("could not receive value {}".format(name)) continue if value_type == "integer" or value_type == "double": print("{}({}) value: {} default: {} min: {} max: {} grouping: {} - {}".format(name, value_type, value, default_value, min_value, max_value, category, group)) elif value_type == "string": print("{}(string) value: {} default: {} grouping: {} - {}".format(name, value, default_value, category, group)) elif value_type == "button": print("{}(button) grouping is {} - {}".format(name, category, group)) elif value_type == "boolean": print("{}(boolean) value: {} default: {} grouping: {} - {}".format(name, value, default_value, category, group)) elif value_type == "enum": enum_entries = camera.get_tcam_menu_entries(name) print("{}(enum) value: {} default: {} grouping {} - {}".format(name, value, default_value, category, group)) print("Entries: ") for entry in enum_entries: print("\t {}".format(entry)) else: print("This should not happen.") def block_until_playing(pipeline): while True: # wait 0.1 seconds for something to happen change_return, state, pending = pipeline.get_state(100000000) if change_return == Gst.StateChangeReturn.SUCCESS: return True elif change_return == Gst.StateChangeReturn.FAILURE: print("Failed to change state {} {} {}".format(change_return, state, pending)) return False def main(): Gst.init(sys.argv) # init gstreamer # this line sets the gstreamer default logging level # it can be removed in normal applications # gstreamer logging can contain verry useful information # when debugging your application # see https://gstreamer.freedesktop.org/documentation/tutorials/basic/debugging-tools.html # for further details Gst.debug_set_default_threshold(Gst.DebugLevel.WARNING) pipeline = Gst.parse_launch("tcambin name=source ! fakesink") if not pipeline: print("Unable to create pipeline") return 1 # set this to a specific camera serial if you # do not want to use the default camera serial = None # get the tcambin to retrieve a property list through it source = pipeline.get_by_name("source") # serial is defined, thus make the source open that device if serial is not None: source.set_property("serial", serial) print("Properties before state PLAYING:") list_properties(source) # in the READY state the camera will always be initialized # in the PLAYING sta1te additional properties may appear from gstreamer elements pipeline.set_state(Gst.State.PLAYING) # helper function to ensure we have the right state # alternatively wait for the first image if not block_until_playing(pipeline): print("Unable to start pipeline") print("Properties during state PLAYING:") list_properties(source) pipeline.set_state(Gst.State.NULL) return 0 if __name__ == "__main__": sys.exit(main())

f730e637b6cdd9ca1951b596c2df73147bceb07c

py

Python

mlir/test/python/integration/dialects/linalg/opsrun.py

mgehre-xlx/sycl

2086745509ef4bc298d7bbec402a123dae68f25e

2019-04-12T18:49:57.000Z

2022-03-19T22:23:16.000Z

mlir/test/python/integration/dialects/linalg/opsrun.py

mgehre-xlx/sycl

2086745509ef4bc298d7bbec402a123dae68f25e

2019-04-09T00:55:50.000Z

2022-03-21T15:35:41.000Z

mlir/test/python/integration/dialects/linalg/opsrun.py

mgehre-xlx/sycl

2086745509ef4bc298d7bbec402a123dae68f25e

2019-04-02T18:25:40.000Z

2022-02-15T07:11:37.000Z

# RUN: %PYTHON %s 2>&1 | FileCheck %s import ctypes import sys from mlir.ir import * from mlir.dialects import builtin from mlir.dialects import linalg from mlir.dialects import std from mlir.passmanager import * from mlir.execution_engine import * # Log everything to stderr and flush so that we have a unified stream to match # errors/info emitted by MLIR to stderr. def log(*args): print(*args, file=sys.stderr) sys.stderr.flush() matmul_boiler = """ func @main() -> f32 attributes {llvm.emit_c_interface} { %v0 = constant 0.0 : f32 %v1 = constant 1.0 : f32 %v2 = constant 2.0 : f32 %A = memref.alloc() : memref<4x16xf32> %B = memref.alloc() : memref<16x8xf32> %C = memref.alloc() : memref<4x8xf32> linalg.fill(%v1, %A) : f32, memref<4x16xf32> linalg.fill(%v2, %B) : f32, memref<16x8xf32> linalg.fill(%v0, %C) : f32, memref<4x8xf32> call @matmul_on_buffers(%A, %B, %C) : (memref<4x16xf32>, memref<16x8xf32>, memref<4x8xf32>) -> () %c0 = constant 0 : index %0 = memref.load %C[%c0, %c0] : memref<4x8xf32> // TODO: FFI-based solution to allow testing and printing with python code. return %0 : f32 } """ fill_boiler = """ func @main() -> i32 attributes {llvm.emit_c_interface} { %O = memref.alloc() : memref<4x16xi32> %min = constant -1000.0 : f64 %max = constant 1000.0 : f64 %seed = constant 42 : i32 call @fill_on_buffers(%min, %max, %seed, %O) : (f64, f64, i32, memref<4x16xi32>) -> () %c0 = constant 0 : index %0 = memref.load %O[%c0, %c0] : memref<4x16xi32> // TODO: FFI-based solution to allow testing and printing with python code. return %0 : i32 } """ conv_boiler = """ func @main() -> i32 attributes {llvm.emit_c_interface} { %v0 = constant 0 : i32 %v1 = constant 1.0 : f64 %v2 = constant 2.0 : f64 %input = memref.alloc() : memref<1x4x16x1xf64> %filter = memref.alloc() : memref<2x2x1xf64> %output = memref.alloc() : memref<1x2x4x1xi32> linalg.fill(%v1, %input) : f64, memref<1x4x16x1xf64> linalg.fill(%v2, %filter) : f64, memref<2x2x1xf64> linalg.fill(%v0, %output) : i32, memref<1x2x4x1xi32> call @conv_on_buffers(%input, %filter, %output) : (memref<1x4x16x1xf64>, memref<2x2x1xf64>, memref<1x2x4x1xi32>) -> () %c0 = constant 0 : index %0 = memref.load %output[%c0, %c0, %c0, %c0] : memref<1x2x4x1xi32> // TODO: FFI-based solution to allow testing and printing with python code. return %0 : i32 } """ pooling_boiler = """ func @main() -> i32 attributes {llvm.emit_c_interface} { %v0 = constant 0 : i32 %v42 = constant 42.0 : f64 %v77 = constant 77.0 : f64 %v-13 = constant -13.0 : f64 %v1 = constant 1.0 : f64 %input = memref.alloc() : memref<1x4x16x1xf64> %shape = memref.alloc() : memref<2x2xf64> %output = memref.alloc() : memref<1x2x4x1xi32> linalg.fill(%v1, %input) : f64, memref<1x4x16x1xf64> linalg.fill(%v1, %shape) : f64, memref<2x2xf64> linalg.fill(%v0, %output) : i32, memref<1x2x4x1xi32> %c0 = constant 0 : index %c1 = constant 1 : index %c2 = constant 2 : index memref.store %v42, %input[%c0, %c0, %c0, %c0] : memref<1x4x16x1xf64> memref.store %v77, %input[%c0, %c0, %c1, %c0] : memref<1x4x16x1xf64> memref.store %v-13, %input[%c0, %c0, %c2, %c0] : memref<1x4x16x1xf64> call @pooling_on_buffers(%input, %shape, %output) : (memref<1x4x16x1xf64>, memref<2x2xf64>, memref<1x2x4x1xi32>) -> () %0 = memref.load %output[%c0, %c0, %c0, %c0] : memref<1x2x4x1xi32> // TODO: FFI-based solution to allow testing and printing with python code. return %0 : i32 } """ def transform(module, boilerplate): import mlir.conversions import mlir.dialects.linalg.passes import mlir.transforms # TODO: Allow cloning functions from one module to another. # Atm we have to resort to string concatenation. mod = Module.parse( str(module.operation.regions[0].blocks[0].operations[0].operation) + boilerplate) pm = PassManager.parse( "builtin.func(convert-linalg-to-loops, lower-affine, " + "convert-scf-to-std), convert-vector-to-llvm," + "convert-memref-to-llvm,convert-std-to-llvm") pm.run(mod) return mod def test_matmul_builtin(): with Context() as ctx, Location.unknown(): module = Module.create() f32 = F32Type.get() with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((4, 16), f32), MemRefType.get((16, 8), f32), MemRefType.get((4, 8), f32)) def matmul_on_buffers(lhs, rhs, out): linalg.matmul(lhs, rhs, outs=[out]) execution_engine = ExecutionEngine(transform(module, matmul_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result f32. # Arguments must be passed as pointers. c_float_p = ctypes.c_float * 1 res = c_float_p(-1.) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: 32.0 test_matmul_builtin() def test_matmul_generic(): with Context() as ctx, Location.unknown(): module = Module.create() f32 = F32Type.get() with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((4, 16), f32), MemRefType.get((16, 8), f32), MemRefType.get((4, 8), f32)) def matmul_on_buffers(lhs, rhs, out): linalg.matmul(lhs, rhs, outs=[out], emit_generic=True) execution_engine = ExecutionEngine(transform(module, matmul_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result f32. # Arguments must be passed as pointers. c_float_p = ctypes.c_float * 1 res = c_float_p(-1.) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: 32.0 test_matmul_generic() def test_fill_builtin(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func(f64, f64, i32, MemRefType.get((4, 16), i32)) def fill_on_buffers(min, max, seed, out): linalg.fill_rng_2d(min, max, seed, outs=[out]) execution_engine = ExecutionEngine(transform(module, fill_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: -480 test_fill_builtin() def test_fill_generic(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func(f64, f64, i32, MemRefType.get((4, 16), i32)) def fill_on_buffers(min, max, seed, out): linalg.fill_rng_2d(min, max, seed, outs=[out], emit_generic=True) execution_engine = ExecutionEngine(transform(module, fill_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: -480 test_fill_generic() def test_conv_builtin(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2, 1), f64), MemRefType.get((1, 2, 4, 1), i32)) def conv_on_buffers(input, filter, output): linalg.depthwise_conv_2d_input_nhwc_filter_hwc_poly( input, filter, outs=[output], strides=[2, 4], dilations=[1, 2]) execution_engine = ExecutionEngine(transform(module, conv_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: 8 test_conv_builtin() def test_conv_generic(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2, 1), f64), MemRefType.get((1, 2, 4, 1), i32)) def conv_on_buffers(input, filter, output): linalg.depthwise_conv_2d_input_nhwc_filter_hwc_poly( input, filter, outs=[output], strides=[2, 4], dilations=[1, 2], emit_generic=True) execution_engine = ExecutionEngine(transform(module, conv_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: 8 test_conv_generic() def test_max_pooling_builtin(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 2, 4, 1), i32)) def pooling_on_buffers(input, shape, output): linalg.pooling_nhwc_max( input, shape, outs=[output], strides=[2, 4], dilations=[1, 2]) execution_engine = ExecutionEngine(transform(module, pooling_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # 77 is not selected due to the dilation 2 in the second dimension. # CHECK: RESULT: 42 test_max_pooling_builtin() def test_max_pooling_generic(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 2, 4, 1), i32)) def pooling_on_buffers(input, shape, output): linalg.pooling_nhwc_max( input, shape, outs=[output], strides=[2, 4], dilations=[1, 2], emit_generic=True) execution_engine = ExecutionEngine(transform(module, pooling_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # 77 is not selected due to the dilation 2 in the second dimension. # CHECK: RESULT: 42 test_max_pooling_generic() def test_min_pooling_builtin(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 2, 4, 1), i32)) def pooling_on_buffers(input, shape, output): linalg.pooling_nhwc_min( input, shape, outs=[output], strides=[2, 4], dilations=[1, 2]) execution_engine = ExecutionEngine(transform(module, pooling_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: -13 test_min_pooling_builtin() def test_min_pooling_generic(): with Context() as ctx, Location.unknown(): module = Module.create() f64 = F64Type.get() i32 = IntegerType.get_signless(32) with InsertionPoint(module.body): @builtin.FuncOp.from_py_func( MemRefType.get((1, 4, 16, 1), f64), MemRefType.get((2, 2), f64), MemRefType.get((1, 2, 4, 1), i32)) def pooling_on_buffers(input, shape, output): linalg.pooling_nhwc_min( input, shape, outs=[output], strides=[2, 4], dilations=[1, 2], emit_generic=True) execution_engine = ExecutionEngine(transform(module, pooling_boiler)) # TODO: FFI-based solution to allow testing and printing with python code. # Prepare arguments: one result i32. # Arguments must be passed as pointers. c_int_p = ctypes.c_int * 1 res = c_int_p(-1) execution_engine.invoke("main", res) log("RESULT: ", res[0]) # CHECK: RESULT: -13 test_min_pooling_generic()

f730f61c0558a354a0cd7c399108c3d7b08479b3

py

Python

Tools/SeeDot/seedot/predictor.py

krantikiran/EdgeML

e5c7bd7c56884ca61f6d54cedb0074553cfdc896

2020-03-26T17:19:54.000Z

2020-03-26T17:19:54.000Z

Tools/SeeDot/seedot/predictor.py

krantikiran/EdgeML

e5c7bd7c56884ca61f6d54cedb0074553cfdc896

2020-03-26T02:59:12.000Z

2020-04-23T19:09:00.000Z

Tools/SeeDot/seedot/predictor.py

krantikiran/EdgeML

e5c7bd7c56884ca61f6d54cedb0074553cfdc896

2020-03-25T18:45:39.000Z

2020-12-17T19:09:54.000Z

# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT license. import os import subprocess import seedot.config as config import seedot.util as Util # Program to build and run the predictor project using msbuild # The accuracy and other statistics are written to the output file specified class Predictor: def __init__(self, algo, version, datasetType, outputDir, scaleForX): self.algo, self.version, self.datasetType = algo, version, datasetType self.outputDir = outputDir os.makedirs(self.outputDir, exist_ok=True) self.scaleForX = scaleForX self.genHeaderFile() def genHeaderFile(self): with open("datatypes.h", 'w') as file: file.write("#pragma once\n\n") if config.wordLength == 8: file.write("#define INT8\n") file.write("typedef int8_t MYINT;\n\n") elif config.wordLength == 16: file.write("#define INT16\n") file.write("typedef int16_t MYINT;\n\n") elif config.wordLength == 32: file.write("#define INT32\n") file.write("typedef int32_t MYINT;\n\n") file.write("typedef int16_t MYITE;\n") file.write("typedef uint16_t MYUINT;\n\n") file.write("const int scaleForX = %d;\n\n" % (self.scaleForX)) if Util.debugMode(): file.write("const bool debugMode = true;\n") else: file.write("const bool debugMode = false;\n") def buildForWindows(self): ''' Builds using the Predictor.vcxproj project file and creates the executable The target platform is currently set to x64 ''' print("Build...", end='') projFile = "Predictor.vcxproj" args = [config.msbuildPath, projFile, r"/t:Build", r"/p:Configuration=Release", r"/p:Platform=x64"] logFile = os.path.join(self.outputDir, "msbuild.txt") with open(logFile, 'w') as file: process = subprocess.call(args, stdout=file, stderr=subprocess.STDOUT) if process == 1: print("FAILED!!\n") return False else: print("success") return True def buildForLinux(self): print("Build...", end='') args = ["make"] logFile = os.path.join(self.outputDir, "build.txt") with open(logFile, 'w') as file: process = subprocess.call(args, stdout=file, stderr=subprocess.STDOUT) if process == 1: print("FAILED!!\n") return False else: print("success") return True def build(self): if Util.windows(): return self.buildForWindows() else: return self.buildForLinux() def executeForWindows(self): ''' Invokes the executable with arguments ''' print("Execution...", end='') exeFile = os.path.join("x64", "Release", "Predictor.exe") args = [exeFile, self.version, self.datasetType] logFile = os.path.join(self.outputDir, "exec.txt") with open(logFile, 'w') as file: process = subprocess.call(args, stdout=file, stderr=subprocess.STDOUT) if process == 1: print("FAILED!!\n") return None else: print("success") acc = self.readStatsFile() return acc def executeForLinux(self): print("Execution...", end='') exeFile = os.path.join("./Predictor") args = [exeFile, self.version, self.datasetType] logFile = os.path.join(self.outputDir, "exec.txt") with open(logFile, 'w') as file: process = subprocess.call(args, stdout=file, stderr=subprocess.STDOUT) if process == 1: print("FAILED!!\n") return None else: print("success") acc = self.readStatsFile() return acc def execute(self): if Util.windows(): return self.executeForWindows() else: return self.executeForLinux() # Read statistics of execution (currently only accuracy) def readStatsFile(self): statsFile = os.path.join( "output", self.version, "stats-" + self.datasetType + ".txt") with open(statsFile, 'r') as file: content = file.readlines() stats = [x.strip() for x in content] return float(stats[0]) def run(self): res = self.build() if res == False: return None acc = self.execute() return acc

f730f6f1c65f95e6079be44f28f2c5b909f64b71

py

Python

flagging_site/data/_store/refresh.py

danivalades/flagging

b1a097594e9b7d9e101edef9bb6abf98a333383c

flagging_site/data/_store/refresh.py

danivalades/flagging

b1a097594e9b7d9e101edef9bb6abf98a333383c