Datasets:

lentan

/

codeparrot-train

like 0

StackStorm/st2

st2reactor/st2reactor/rules/matcher.py

3

3079

# Copyright 2020 The StackStorm Authors. # Copyright 2019 Extreme Networks, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import absolute_import from st2common import log as logging from st2common.constants.rules import RULE_TYPE_BACKSTOP from st2reactor.rules.filter import RuleFilter, SecondPassRuleFilter LOG = logging.getLogger("st2reactor.rules.RulesMatcher") class RulesMatcher(object): def __init__(self, trigger_instance, trigger, rules, extra_info=False): self.trigger_instance = trigger_instance self.trigger = trigger self.rules = rules self.extra_info = extra_info def get_matching_rules(self): first_pass, second_pass = self._split_rules_into_passes() # first pass rule_filters = [ RuleFilter( trigger_instance=self.trigger_instance, trigger=self.trigger, rule=rule, extra_info=self.extra_info, ) for rule in first_pass ] matched_rules = [ rule_filter.rule for rule_filter in rule_filters if rule_filter.filter() ] LOG.debug( "[1st_pass] %d rule(s) found to enforce for %s.", len(matched_rules), self.trigger["name"], ) # second pass rule_filters = [ SecondPassRuleFilter( self.trigger_instance, self.trigger, rule, matched_rules ) for rule in second_pass ] matched_in_second_pass = [ rule_filter.rule for rule_filter in rule_filters if rule_filter.filter() ] LOG.debug( "[2nd_pass] %d rule(s) found to enforce for %s.", len(matched_in_second_pass), self.trigger["name"], ) matched_rules.extend(matched_in_second_pass) LOG.info( "%d rule(s) found to enforce for %s.", len(matched_rules), self.trigger["name"], ) return matched_rules def _split_rules_into_passes(self): """ Splits the rules in the Matcher into first_pass and second_pass collections. Since the """ first_pass = [] second_pass = [] for rule in self.rules: if self._is_first_pass_rule(rule): first_pass.append(rule) else: second_pass.append(rule) return first_pass, second_pass def _is_first_pass_rule(self, rule): return rule.type["ref"] != RULE_TYPE_BACKSTOP

apache-2.0

ranjinidas/Axelrod

axelrod/tests/unit/test_ecosystem.py

4

3370

"""Tests for the Ecosystem class""" import unittest import axelrod class TestEcosystem(unittest.TestCase): @classmethod def setUpClass(cls): cooperators = axelrod.Tournament(players=[ axelrod.Cooperator(), axelrod.Cooperator(), axelrod.Cooperator(), axelrod.Cooperator(), ]) defector_wins = axelrod.Tournament(players=[ axelrod.Cooperator(), axelrod.Cooperator(), axelrod.Cooperator(), axelrod.Defector(), ]) cls.res_cooperators = cooperators.play() cls.res_defector_wins = defector_wins.play() def test_init(self): """Are the populations created correctly?""" # By default create populations of equal size eco = axelrod.Ecosystem(self.res_cooperators) pops = eco.population_sizes self.assertEqual(eco.nplayers, 4) self.assertEqual(len(pops), 1) self.assertEqual(len(pops[0]), 4) self.assertAlmostEqual(sum(pops[0]), 1.0) self.assertEqual(list(set(pops[0])), [0.25]) # Can pass list of initial population distributions eco = axelrod.Ecosystem(self.res_cooperators, population=[.7, .25, .03, .02]) pops = eco.population_sizes self.assertEqual(eco.nplayers, 4) self.assertEqual(len(pops), 1) self.assertEqual(len(pops[0]), 4) self.assertAlmostEqual(sum(pops[0]), 1.0) self.assertEqual(pops[0], [.7, .25, .03, .02]) # Distribution will automatically normalise eco = axelrod.Ecosystem(self.res_cooperators, population=[70, 25, 3, 2]) pops = eco.population_sizes self.assertEqual(eco.nplayers, 4) self.assertEqual(len(pops), 1) self.assertEqual(len(pops[0]), 4) self.assertAlmostEqual(sum(pops[0]), 1.0) self.assertEqual(pops[0], [.7, .25, .03, .02]) # If passed list is of incorrect size get error self.assertRaises(TypeError, axelrod.Ecosystem, self.res_cooperators, population=[.7, .2, .03, .1, .1]) # If passed list has negative values self.assertRaises(TypeError, axelrod.Ecosystem, self.res_cooperators, population=[.7, -.2, .03, .2]) def test_fitness(self): fitness = lambda p: 2 * p eco = axelrod.Ecosystem(self.res_cooperators, fitness=fitness) self.assertTrue(eco.fitness(10), 20) def test_cooperators(self): """Are cooperators stable over time?""" eco = axelrod.Ecosystem(self.res_cooperators) eco.reproduce(100) pops = eco.population_sizes self.assertEqual(len(pops), 101) for p in pops: self.assertEqual(len(p), 4) self.assertEqual(sum(p), 1.0) self.assertEqual(list(set(p)), [0.25]) def test_defector_wins(self): """Does one defector win over time?""" eco = axelrod.Ecosystem(self.res_defector_wins) eco.reproduce(1000) pops = eco.population_sizes self.assertEqual(len(pops), 1001) for p in pops: self.assertEqual(len(p), 4) self.assertAlmostEqual(sum(p), 1.0) last = pops[-1] self.assertAlmostEqual(last[0], 0.0) self.assertAlmostEqual(last[1], 0.0) self.assertAlmostEqual(last[2], 0.0) self.assertAlmostEqual(last[3], 1.0)

mit

revoer/keystone-8.0.0

swift/container/sync.py

1

29912

# Copyright (c) 2010-2012 OpenStack Foundation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or # implied. # See the License for the specific language governing permissions and # limitations under the License. import collections import errno import os import uuid from swift import gettext_ as _ from time import ctime, time from random import choice, random from struct import unpack_from from eventlet import sleep, Timeout import swift.common.db from swift.common.db import DatabaseConnectionError from swift.container.backend import ContainerBroker from swift.container.sync_store import ContainerSyncStore from swift.common.container_sync_realms import ContainerSyncRealms from swift.common.internal_client import ( delete_object, put_object, head_object, InternalClient, UnexpectedResponse) from swift.common.exceptions import ClientException from swift.common.ring import Ring from swift.common.ring.utils import is_local_device from swift.common.utils import ( clean_content_type, config_true_value, FileLikeIter, get_logger, hash_path, quote, urlparse, validate_sync_to, whataremyips, Timestamp, decode_timestamps) from swift.common.daemon import Daemon from swift.common.http import HTTP_UNAUTHORIZED, HTTP_NOT_FOUND from swift.common.wsgi import ConfigString # The default internal client config body is to support upgrades without # requiring deployment of the new /etc/swift/internal-client.conf ic_conf_body = """ [DEFAULT] # swift_dir = /etc/swift # user = swift # You can specify default log routing here if you want: # log_name = swift # log_facility = LOG_LOCAL0 # log_level = INFO # log_address = /dev/log # # comma separated list of functions to call to setup custom log handlers. # functions get passed: conf, name, log_to_console, log_route, fmt, logger, # adapted_logger # log_custom_handlers = # # If set, log_udp_host will override log_address # log_udp_host = # log_udp_port = 514 # # You can enable StatsD logging here: # log_statsd_host = # log_statsd_port = 8125 # log_statsd_default_sample_rate = 1.0 # log_statsd_sample_rate_factor = 1.0 # log_statsd_metric_prefix = [pipeline:main] pipeline = catch_errors proxy-logging cache proxy-server [app:proxy-server] use = egg:swift#proxy # See proxy-server.conf-sample for options [filter:cache] use = egg:swift#memcache # See proxy-server.conf-sample for options [filter:proxy-logging] use = egg:swift#proxy_logging [filter:catch_errors] use = egg:swift#catch_errors # See proxy-server.conf-sample for options """.lstrip() class ContainerSync(Daemon): """ Daemon to sync syncable containers. This is done by scanning the local devices for container databases and checking for x-container-sync-to and x-container-sync-key metadata values. If they exist, newer rows since the last sync will trigger PUTs or DELETEs to the other container. The actual syncing is slightly more complicated to make use of the three (or number-of-replicas) main nodes for a container without each trying to do the exact same work but also without missing work if one node happens to be down. Two sync points are kept per container database. All rows between the two sync points trigger updates. Any rows newer than both sync points cause updates depending on the node's position for the container (primary nodes do one third, etc. depending on the replica count of course). After a sync run, the first sync point is set to the newest ROWID known and the second sync point is set to newest ROWID for which all updates have been sent. An example may help. Assume replica count is 3 and perfectly matching ROWIDs starting at 1. First sync run, database has 6 rows: * SyncPoint1 starts as -1. * SyncPoint2 starts as -1. * No rows between points, so no "all updates" rows. * Six rows newer than SyncPoint1, so a third of the rows are sent by node 1, another third by node 2, remaining third by node 3. * SyncPoint1 is set as 6 (the newest ROWID known). * SyncPoint2 is left as -1 since no "all updates" rows were synced. Next sync run, database has 12 rows: * SyncPoint1 starts as 6. * SyncPoint2 starts as -1. * The rows between -1 and 6 all trigger updates (most of which should short-circuit on the remote end as having already been done). * Six more rows newer than SyncPoint1, so a third of the rows are sent by node 1, another third by node 2, remaining third by node 3. * SyncPoint1 is set as 12 (the newest ROWID known). * SyncPoint2 is set as 6 (the newest "all updates" ROWID). In this way, under normal circumstances each node sends its share of updates each run and just sends a batch of older updates to ensure nothing was missed. :param conf: The dict of configuration values from the [container-sync] section of the container-server.conf :param container_ring: If None, the <swift_dir>/container.ring.gz will be loaded. This is overridden by unit tests. """ def __init__(self, conf, container_ring=None, logger=None): #: The dict of configuration values from the [container-sync] section #: of the container-server.conf. self.conf = conf #: Logger to use for container-sync log lines. self.logger = logger or get_logger(conf, log_route='container-sync') #: Path to the local device mount points. self.devices = conf.get('devices', '/srv/node') #: Indicates whether mount points should be verified as actual mount #: points (normally true, false for tests and SAIO). self.mount_check = config_true_value(conf.get('mount_check', 'true')) #: Minimum time between full scans. This is to keep the daemon from #: running wild on near empty systems. self.interval = int(conf.get('interval', 300)) #: Maximum amount of time to spend syncing a container before moving on #: to the next one. If a container sync hasn't finished in this time, #: it'll just be resumed next scan. self.container_time = int(conf.get('container_time', 60)) #: ContainerSyncCluster instance for validating sync-to values. self.realms_conf = ContainerSyncRealms( os.path.join( conf.get('swift_dir', '/etc/swift'), 'container-sync-realms.conf'), self.logger) #: The list of hosts we're allowed to send syncs to. This can be #: overridden by data in self.realms_conf self.allowed_sync_hosts = [ h.strip() for h in conf.get('allowed_sync_hosts', '127.0.0.1').split(',') if h.strip()] self.http_proxies = [ a.strip() for a in conf.get('sync_proxy', '').split(',') if a.strip()] #: ContainerSyncStore instance for iterating over synced containers self.sync_store = ContainerSyncStore(self.devices, self.logger, self.mount_check) #: Number of containers with sync turned on that were successfully #: synced. self.container_syncs = 0 #: Number of successful DELETEs triggered. self.container_deletes = 0 #: Number of successful PUTs triggered. self.container_puts = 0 #: Number of containers whose sync has been turned off, but #: are not yet cleared from the sync store. self.container_skips = 0 #: Number of containers that had a failure of some type. self.container_failures = 0 #: Per container stats. These are collected per container. #: puts - the number of puts that were done for the container #: deletes - the number of deletes that were fot the container #: bytes - the total number of bytes transferred per the container self.container_stats = collections.defaultdict(int) self.container_stats.clear() #: Time of last stats report. self.reported = time() self.swift_dir = conf.get('swift_dir', '/etc/swift') #: swift.common.ring.Ring for locating containers. self.container_ring = container_ring or Ring(self.swift_dir, ring_name='container') bind_ip = conf.get('bind_ip', '0.0.0.0') self._myips = whataremyips(bind_ip) self._myport = int(conf.get('bind_port', 6201)) swift.common.db.DB_PREALLOCATION = \ config_true_value(conf.get('db_preallocation', 'f')) self.conn_timeout = float(conf.get('conn_timeout', 5)) request_tries = int(conf.get('request_tries') or 3) internal_client_conf_path = conf.get('internal_client_conf_path') if not internal_client_conf_path: self.logger.warning( _('Configuration option internal_client_conf_path not ' 'defined. Using default configuration, See ' 'internal-client.conf-sample for options')) internal_client_conf = ConfigString(ic_conf_body) else: internal_client_conf = internal_client_conf_path try: self.swift = InternalClient( internal_client_conf, 'Swift Container Sync', request_tries) except IOError as err: if err.errno != errno.ENOENT: raise raise SystemExit( _('Unable to load internal client from config: %r (%s)') % (internal_client_conf_path, err)) def run_forever(self, *args, **kwargs): """ Runs container sync scans until stopped. """ sleep(random() * self.interval) while True: begin = time() for path in self.sync_store.synced_containers_generator(): self.container_stats.clear() self.container_sync(path) if time() - self.reported >= 3600: # once an hour self.report() elapsed = time() - begin if elapsed < self.interval: sleep(self.interval - elapsed) def run_once(self, *args, **kwargs): """ Runs a single container sync scan. """ self.logger.info(_('Begin container sync "once" mode')) begin = time() for path in self.sync_store.synced_containers_generator(): self.container_sync(path) if time() - self.reported >= 3600: # once an hour self.report() self.report() elapsed = time() - begin self.logger.info( _('Container sync "once" mode completed: %.02fs'), elapsed) def report(self): """ Writes a report of the stats to the logger and resets the stats for the next report. """ self.logger.info( _('Since %(time)s: %(sync)s synced [%(delete)s deletes, %(put)s ' 'puts], %(skip)s skipped, %(fail)s failed'), {'time': ctime(self.reported), 'sync': self.container_syncs, 'delete': self.container_deletes, 'put': self.container_puts, 'skip': self.container_skips, 'fail': self.container_failures}) self.reported = time() self.container_syncs = 0 self.container_deletes = 0 self.container_puts = 0 self.container_skips = 0 self.container_failures = 0 def container_report(self, start, end, sync_point1, sync_point2, info, max_row): self.logger.info(_('Container sync report: %(container)s, ' 'time window start: %(start)s, ' 'time window end: %(end)s, ' 'puts: %(puts)s, ' 'posts: %(posts)s, ' 'deletes: %(deletes)s, ' 'bytes: %(bytes)s, ' 'sync_point1: %(point1)s, ' 'sync_point2: %(point2)s, ' 'total_rows: %(total)s'), {'container': '%s/%s' % (info['account'], info['container']), 'start': start, 'end': end, 'puts': self.container_stats['puts'], 'posts': 0, 'deletes': self.container_stats['deletes'], 'bytes': self.container_stats['bytes'], 'point1': sync_point1, 'point2': sync_point2, 'total': max_row}) def container_sync(self, path): """ Checks the given path for a container database, determines if syncing is turned on for that database and, if so, sends any updates to the other container. :param path: the path to a container db """ broker = None try: broker = ContainerBroker(path) # The path we pass to the ContainerBroker is a real path of # a container DB. If we get here, however, it means that this # path is linked from the sync_containers dir. In rare cases # of race or processes failures the link can be stale and # the get_info below will raise a DB doesn't exist exception # In this case we remove the stale link and raise an error # since in most cases the db should be there. try: info = broker.get_info() except DatabaseConnectionError as db_err: if str(db_err).endswith("DB doesn't exist"): self.sync_store.remove_synced_container(broker) raise x, nodes = self.container_ring.get_nodes(info['account'], info['container']) for ordinal, node in enumerate(nodes): if is_local_device(self._myips, self._myport, node['ip'], node['port']): break else: return if not broker.is_deleted(): sync_to = None user_key = None sync_point1 = info['x_container_sync_point1'] sync_point2 = info['x_container_sync_point2'] for key, (value, timestamp) in broker.metadata.items(): if key.lower() == 'x-container-sync-to': sync_to = value elif key.lower() == 'x-container-sync-key': user_key = value if not sync_to or not user_key: self.container_skips += 1 self.logger.increment('skips') return err, sync_to, realm, realm_key = validate_sync_to( sync_to, self.allowed_sync_hosts, self.realms_conf) if err: self.logger.info( _('ERROR %(db_file)s: %(validate_sync_to_err)s'), {'db_file': str(broker), 'validate_sync_to_err': err}) self.container_failures += 1 self.logger.increment('failures') return start_at = time() stop_at = start_at + self.container_time next_sync_point = None sync_stage_time = start_at try: while time() < stop_at and sync_point2 < sync_point1: rows = broker.get_items_since(sync_point2, 1) if not rows: break row = rows[0] if row['ROWID'] > sync_point1: break # This node will only initially sync out one third # of the objects (if 3 replicas, 1/4 if 4, etc.) # and will skip problematic rows as needed in case of # faults. # This section will attempt to sync previously skipped # rows in case the previous attempts by any of the # nodes didn't succeed. if not self.container_sync_row( row, sync_to, user_key, broker, info, realm, realm_key): if not next_sync_point: next_sync_point = sync_point2 sync_point2 = row['ROWID'] broker.set_x_container_sync_points(None, sync_point2) if next_sync_point: broker.set_x_container_sync_points(None, next_sync_point) else: next_sync_point = sync_point2 sync_stage_time = time() while sync_stage_time < stop_at: rows = broker.get_items_since(sync_point1, 1) if not rows: break row = rows[0] key = hash_path(info['account'], info['container'], row['name'], raw_digest=True) # This node will only initially sync out one third of # the objects (if 3 replicas, 1/4 if 4, etc.). # It'll come back around to the section above # and attempt to sync previously skipped rows in case # the other nodes didn't succeed or in case it failed # to do so the first time. if unpack_from('>I', key)[0] % \ len(nodes) == ordinal: self.container_sync_row( row, sync_to, user_key, broker, info, realm, realm_key) sync_point1 = row['ROWID'] broker.set_x_container_sync_points(sync_point1, None) sync_stage_time = time() self.container_syncs += 1 self.logger.increment('syncs') except Exception as ex: raise ex finally: self.container_report(start_at, sync_stage_time, sync_point1, next_sync_point, info, broker.get_max_row()) except (Exception, Timeout): self.container_failures += 1 self.logger.increment('failures') self.logger.exception(_('ERROR Syncing %s'), broker if broker else path) def _update_sync_to_headers(self, name, sync_to, user_key, realm, realm_key, method, headers): """ Updates container sync headers :param name: The name of the object :param sync_to: The URL to the remote container. :param user_key: The X-Container-Sync-Key to use when sending requests to the other container. :param realm: The realm from self.realms_conf, if there is one. If None, fallback to using the older allowed_sync_hosts way of syncing. :param realm_key: The realm key from self.realms_conf, if there is one. If None, fallback to using the older allowed_sync_hosts way of syncing. :param method: HTTP method to create sig with :param headers: headers to update with container sync headers """ if realm and realm_key: nonce = uuid.uuid4().hex path = urlparse(sync_to).path + '/' + quote(name) sig = self.realms_conf.get_sig(method, path, headers.get('x-timestamp', 0), nonce, realm_key, user_key) headers['x-container-sync-auth'] = '%s %s %s' % (realm, nonce, sig) else: headers['x-container-sync-key'] = user_key def _object_in_remote_container(self, name, sync_to, user_key, realm, realm_key, timestamp): """ Performs head object on remote to eliminate extra remote put and local get object calls :param name: The name of the object in the updated row in the local database triggering the sync update. :param sync_to: The URL to the remote container. :param user_key: The X-Container-Sync-Key to use when sending requests to the other container. :param realm: The realm from self.realms_conf, if there is one. If None, fallback to using the older allowed_sync_hosts way of syncing. :param realm_key: The realm key from self.realms_conf, if there is one. If None, fallback to using the older allowed_sync_hosts way of syncing. :param timestamp: last modified date of local object :returns: True if object already exists in remote """ headers = {'x-timestamp': timestamp.internal} self._update_sync_to_headers(name, sync_to, user_key, realm, realm_key, 'HEAD', headers) try: metadata, _ = head_object(sync_to, name=name, headers=headers, proxy=self.select_http_proxy(), logger=self.logger, retries=0) remote_ts = Timestamp(metadata.get('x-timestamp', 0)) self.logger.debug("remote obj timestamp %s local obj %s" % (timestamp.internal, remote_ts.internal)) if timestamp <= remote_ts: return True # Object in remote should be updated return False except ClientException as http_err: # Object not in remote if http_err.http_status == 404: return False raise http_err def container_sync_row(self, row, sync_to, user_key, broker, info, realm, realm_key): """ Sends the update the row indicates to the sync_to container. Update can be either delete or put. :param row: The updated row in the local database triggering the sync update. :param sync_to: The URL to the remote container. :param user_key: The X-Container-Sync-Key to use when sending requests to the other container. :param broker: The local container database broker. :param info: The get_info result from the local container database broker. :param realm: The realm from self.realms_conf, if there is one. If None, fallback to using the older allowed_sync_hosts way of syncing. :param realm_key: The realm key from self.realms_conf, if there is one. If None, fallback to using the older allowed_sync_hosts way of syncing. :returns: True on success """ try: start_time = time() # extract last modified time from the created_at value ts_data, ts_ctype, ts_meta = decode_timestamps( row['created_at']) if row['deleted']: # when sync'ing a deleted object, use ts_data - this is the # timestamp of the source tombstone try: headers = {'x-timestamp': ts_data.internal} self._update_sync_to_headers(row['name'], sync_to, user_key, realm, realm_key, 'DELETE', headers) delete_object(sync_to, name=row['name'], headers=headers, proxy=self.select_http_proxy(), logger=self.logger, timeout=self.conn_timeout) except ClientException as err: if err.http_status != HTTP_NOT_FOUND: raise self.container_deletes += 1 self.container_stats['deletes'] += 1 self.logger.increment('deletes') self.logger.timing_since('deletes.timing', start_time) else: # when sync'ing a live object, use ts_meta - this is the time # at which the source object was last modified by a PUT or POST if self._object_in_remote_container(row['name'], sync_to, user_key, realm, realm_key, ts_meta): return True exc = None # look up for the newest one headers_out = {'X-Newest': True, 'X-Backend-Storage-Policy-Index': str(info['storage_policy_index'])} try: source_obj_status, headers, body = \ self.swift.get_object(info['account'], info['container'], row['name'], headers=headers_out, acceptable_statuses=(2, 4)) except (Exception, UnexpectedResponse, Timeout) as err: headers = {} body = None exc = err timestamp = Timestamp(headers.get('x-timestamp', 0)) if timestamp < ts_meta: if exc: raise exc raise Exception( _('Unknown exception trying to GET: ' '%(account)r %(container)r %(object)r'), {'account': info['account'], 'container': info['container'], 'object': row['name']}) for key in ('date', 'last-modified'): if key in headers: del headers[key] if 'etag' in headers: headers['etag'] = headers['etag'].strip('"') if 'content-type' in headers: headers['content-type'] = clean_content_type( headers['content-type']) self._update_sync_to_headers(row['name'], sync_to, user_key, realm, realm_key, 'PUT', headers) put_object(sync_to, name=row['name'], headers=headers, contents=FileLikeIter(body), proxy=self.select_http_proxy(), logger=self.logger, timeout=self.conn_timeout) self.container_puts += 1 self.container_stats['puts'] += 1 self.container_stats['bytes'] += row['size'] self.logger.increment('puts') self.logger.timing_since('puts.timing', start_time) except ClientException as err: if err.http_status == HTTP_UNAUTHORIZED: self.logger.info( _('Unauth %(sync_from)r => %(sync_to)r'), {'sync_from': '%s/%s' % (quote(info['account']), quote(info['container'])), 'sync_to': sync_to}) elif err.http_status == HTTP_NOT_FOUND: self.logger.info( _('Not found %(sync_from)r => %(sync_to)r \ - object %(obj_name)r'), {'sync_from': '%s/%s' % (quote(info['account']), quote(info['container'])), 'sync_to': sync_to, 'obj_name': row['name']}) else: self.logger.exception( _('ERROR Syncing %(db_file)s %(row)s'), {'db_file': str(broker), 'row': row}) self.container_failures += 1 self.logger.increment('failures') return False except (Exception, Timeout) as err: self.logger.exception( _('ERROR Syncing %(db_file)s %(row)s'), {'db_file': str(broker), 'row': row}) self.container_failures += 1 self.logger.increment('failures') return False return True def select_http_proxy(self): return choice(self.http_proxies) if self.http_proxies else None

apache-2.0

openlawlibrary/pygls

tests/lsp/test_hover.py

1

5452

############################################################################ # Copyright(c) Open Law Library. All rights reserved. # # See ThirdPartyNotices.txt in the project root for additional notices. # # # # Licensed under the Apache License, Version 2.0 (the "License") # # you may not use this file except in compliance with the License. # # You may obtain a copy of the License at # # # # http: // www.apache.org/licenses/LICENSE-2.0 # # # # Unless required by applicable law or agreed to in writing, software # # distributed under the License is distributed on an "AS IS" BASIS, # # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # # See the License for the specific language governing permissions and # # limitations under the License. # ############################################################################ import unittest from typing import Optional from pygls.lsp.methods import HOVER from pygls.lsp.types import (Hover, HoverOptions, HoverParams, MarkedString, MarkupContent, MarkupKind, Position, Range, TextDocumentIdentifier) from ..conftest import CALL_TIMEOUT, ClientServer class TestHover(unittest.TestCase): @classmethod def setUpClass(cls): cls.client_server = ClientServer() cls.client, cls.server = cls.client_server @cls.server.feature( HOVER, HoverOptions(), ) def f(params: HoverParams) -> Optional[Hover]: range = Range( start=Position(line=0, character=0), end=Position(line=1, character=1), ) return { 'file://return.marked_string': Hover( range=range, contents=MarkedString( language='language', value='value', ), ), 'file://return.marked_string_list': Hover( range=range, contents=[ MarkedString( language='language', value='value', ), 'str type' ], ), 'file://return.markup_content': Hover( range=range, contents=MarkupContent( kind=MarkupKind.Markdown, value='value' ), ), }.get(params.text_document.uri, None) cls.client_server.start() @classmethod def tearDownClass(cls): cls.client_server.stop() def test_capabilities(self): capabilities = self.server.server_capabilities assert capabilities.hover_provider def test_hover_return_marked_string(self): response = self.client.lsp.send_request( HOVER, HoverParams( text_document=TextDocumentIdentifier(uri='file://return.marked_string'), position=Position(line=0, character=0), ), ).result(timeout=CALL_TIMEOUT) assert response assert response['contents']['language'] == 'language' assert response['contents']['value'] == 'value' assert response['range']['start']['line'] == 0 assert response['range']['start']['character'] == 0 assert response['range']['end']['line'] == 1 assert response['range']['end']['character'] == 1 def test_hover_return_marked_string_list(self): response = self.client.lsp.send_request( HOVER, HoverParams( text_document=TextDocumentIdentifier(uri='file://return.marked_string_list'), position=Position(line=0, character=0), ), ).result(timeout=CALL_TIMEOUT) assert response assert response['contents'][0]['language'] == 'language' assert response['contents'][0]['value'] == 'value' assert response['contents'][1] == 'str type' assert response['range']['start']['line'] == 0 assert response['range']['start']['character'] == 0 assert response['range']['end']['line'] == 1 assert response['range']['end']['character'] == 1 def test_hover_return_markup_content(self): response = self.client.lsp.send_request( HOVER, HoverParams( text_document=TextDocumentIdentifier(uri='file://return.markup_content'), position=Position(line=0, character=0), ), ).result(timeout=CALL_TIMEOUT) assert response assert response['contents']['kind'] == MarkupKind.Markdown assert response['contents']['value'] == 'value' assert response['range']['start']['line'] == 0 assert response['range']['start']['character'] == 0 assert response['range']['end']['line'] == 1 assert response['range']['end']['character'] == 1 if __name__ == '__main__': unittest.main()

apache-2.0

Swiftb0y/P4wnP1

hidtools/mouse/hid_mouse.py

3

4850

#!/usr/bin/python # This file is part of P4wnP1. # # Copyright (c) 2017, Marcus Mengs. # # P4wnP1 is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # P4wnP1 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with P4wnP1. If not, see <http://www.gnu.org/licenses/>. import struct import sys class hid_mouse(object) : def __init__(self, absolute=False, outfile="/dev/hidg2"): self.button1 = False self.button2 = False self.button3 = False self._x_abs = 0.0 self._y_abs = 0.0 self.outf = outfile self._abs = absolute self.bleft = 0 self.bright = 32767 self.btop = 0 self.bbottom = 32767 self._x_abs_short = self.bleft self._y_abs_short = self.btop self._x_rel = 0 self._y_rel = 0 @property def x_rel(self): return self._x_rel @x_rel.setter def x_rel(self, value): # in case the last coordinate change was relative, we disable absolute mode self._abs = False self._x_rel = value @property def y_rel(self): return self._y_rel @y_rel.setter def y_rel(self, value): # in case the last coordinate change was relative, we disable absolute mode self._abs = False self._y_rel = value @property def x_abs(self): return self._x_abs @x_abs.setter def x_abs(self, value): # in case the last coordinate change was absolute, we enable absolute mode self._abs = True self._x_abs = self.clamp_float(value) self._x_abs_short = self.scaled_short(self._x_abs, self.bleft, self.bright) @property def y_abs(self): return self._y_abs @y_abs.setter def y_abs(self, value): # in case the last coordinate change was absolute, we enable absolute mode self._abs = True self._y_abs = self.clamp_float(value) self._y_abs_short = self.scaled_short(self._y_abs, self.btop, self.bbottom) def clamp_float(self, val): return min(max(0.0, val), 1.0) def scaled_short(self, val, lower, upper): #print "val {0}".format(val) lower = min(max(-32768, lower), 32767) upper = min(max(-32768, upper), 32767) val = self.clamp_float(val) dim = upper - lower #print "dim {0}".format(dim) scaled = int(lower + val*dim) #print "clamped val {0} scaled {1}".format(val, scaled) return scaled def gen_out_report_abs(self): #xout = hid_mouse.convert_pos_short(self._x_abs) xout = struct.pack("<h", int(self._x_abs_short)) # signed short, little endian #yout = hid_mouse.convert_pos_short(self._y_abs) yout = struct.pack("<h", int(self._y_abs_short)) # signed short, little endian btnout = hid_mouse.convert_btn_byte(self.button1, self.button2, self.button3) return "\x02" + btnout + xout + yout def gen_out_report_rel(self): #xout = hid_mouse.convert_pos_short(self._x_abs) xout = struct.pack("<b", int(self._x_rel)) # signed short, little endian #yout = hid_mouse.convert_pos_short(self._y_abs) yout = struct.pack("<b", int(self._y_rel)) # signed short, little endian btnout = hid_mouse.convert_btn_byte(self.button1, self.button2, self.button3) return "\x01" + btnout + xout + yout + "\x00\x00" def fire_report(self): with open(self.outf, "wb") as f: if self._abs: #print "absolute x: {0} ({1})\ty: {2} ({3})".format(self._x_abs, self._x_abs_short, self._y_abs, self._y_abs_short) f.write(self.gen_out_report_abs()) else: #print "relative x: {0} \ty: {1}".format(self.x_rel, self.y_rel) f.write(self.gen_out_report_rel()) f.flush() @staticmethod def convert_btn_byte(btn1=False, btn2=False, btn3=False): res = 0x00 if btn1: res += 0x01 if btn2: res += 0x02 if btn3: res += 0x04 return struct.pack("<B", res) @staticmethod def convert_pos_short(val): # clamp val valf = max(min(val, 1.0), 0.0) valx = valf * 0x7FFF # scale to 0x7FFF # valx = valf * 10000 + 1 # scale from 0x0001 to 0x7FFF res = struct.pack("<h", int(valx)) # signed short, little endian return res @staticmethod def convert_pos_short(val): # clamp val valf = max(min(val, 1.0), 0.0) valx = valf * 0x7FFE + 1 # scale from 0x0001 to 0x7FFF # valx = valf * 10000 + 1 # scale from 0x0001 to 0x7FFF res = struct.pack("<h", int(valx)) # signed short, little endian return res @staticmethod def bytes2hexstr(bytes): return "\\x"+"\\x".join("{:02x}".format(ord(c)) for c in bytes) @staticmethod def convert_pos_str(val): res = hid_mouse.convert_pos_short(val) res_str = hid_mouse.bytes2hexstr(res) return res_str

gpl-3.0

pedropenna/.emacs.d

elpa/floobits-20160804.1135/floo/common/cert.py

3

4988

CA_CERT = '''-----BEGIN CERTIFICATE----- MIIGNDCCBBygAwIBAgIBGzANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJJTDEW MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh dGlvbiBBdXRob3JpdHkwHhcNMDcxMDI0MjA1NzA5WhcNMTcxMDI0MjA1NzA5WjCB jDELMAkGA1UEBhMCSUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0ZC4xKzApBgNVBAsT IlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25pbmcxODA2BgNVBAMTL1N0 YXJ0Q29tIENsYXNzIDIgUHJpbWFyeSBJbnRlcm1lZGlhdGUgU2VydmVyIENBMIIB IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4k85L6GMmoWtCA4IPlfyiAEh G5SpbOK426oZGEY6UqH1D/RujOqWjJaHeRNAUS8i8gyLhw9l33F0NENVsTUJm9m8 H/rrQtCXQHK3Q5Y9upadXVACHJuRjZzArNe7LxfXyz6CnXPrB0KSss1ks3RVG7RL hiEs93iHMuAW5Nq9TJXqpAp+tgoNLorPVavD5d1Bik7mb2VsskDPF125w2oLJxGE d2H2wnztwI14FBiZgZl1Y7foU9O6YekO+qIw80aiuckfbIBaQKwn7UhHM7BUxkYa 8zVhwQIpkFR+ZE3EMFICgtffziFuGJHXuKuMJxe18KMBL47SLoc6PbQpZ4rEAwID AQABo4IBrTCCAakwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD VR0OBBYEFBHbI0X9VMxqcW+EigPXvvcBLyaGMB8GA1UdIwQYMBaAFE4L7xqkQFul F2mHMMo0aEPQQa7yMGYGCCsGAQUFBwEBBFowWDAnBggrBgEFBQcwAYYbaHR0cDov L29jc3Auc3RhcnRzc2wuY29tL2NhMC0GCCsGAQUFBzAChiFodHRwOi8vd3d3LnN0 YXJ0c3NsLmNvbS9zZnNjYS5jcnQwWwYDVR0fBFQwUjAnoCWgI4YhaHR0cDovL3d3 dy5zdGFydHNzbC5jb20vc2ZzY2EuY3JsMCegJaAjhiFodHRwOi8vY3JsLnN0YXJ0 c3NsLmNvbS9zZnNjYS5jcmwwgYAGA1UdIAR5MHcwdQYLKwYBBAGBtTcBAgEwZjAu BggrBgEFBQcCARYiaHR0cDovL3d3dy5zdGFydHNzbC5jb20vcG9saWN5LnBkZjA0 BggrBgEFBQcCARYoaHR0cDovL3d3dy5zdGFydHNzbC5jb20vaW50ZXJtZWRpYXRl LnBkZjANBgkqhkiG9w0BAQsFAAOCAgEAbQjxXHkqUPtUY+u8NEFcuKMDITfjvGkl LgrTuBW63grW+2AuDAZRo/066eNHs6QV4i5e4ujwPSR2dgggY7mOIIBmiDm2QRjF 5CROq6zDlIdqlsFZICkuONDNFpFjaPtZRTmuK1n6gywQgCNSIrbzjPcwR/jL/wow bfwC9yGme1EeZRqvWy/HzFWacs7UMmWlRk6DTmpfPOPMJo5AxyTZCiCYQQeksV7x UAeY0kWa+y/FV+eerOPUl6yy4jRHTk7tCySxrciZwYbd6YNLmeIQoUAdRC3CH3nT B2/JYxltcgyGHMiPU3TtafZgLs8fvncv+wIF1YAF/OGqg8qmzoJ3ghM4upGdTMIu 8vADdmuLC/+dnbzknxX6QEGlWA8zojLUxVhGNfIFoizu/V/DyvSvYuxzzIkPECK5 gDoMoBTTMI/wnxXwulNPtfgF7/5AtDhA4GNAfB2SddxiNQAF7XkUHtMZ9ff3W6Xk FldOG+NlLFqsDBG/KLckyFK36gq+FqNFCbmtmtXBGB5L1fDIeYzcMKG6hFQxhHS0 oqpdHhp2nWBfLlOnTNqIZNJzOH37OJE6Olk45LNFJtSrqIAZyCCfM6bQgoQvZuIa xs9SIp+63ZMk9TxEaQj/KteaOyfaPXI9778U7JElMTz3Bls62mslV2I1C/A73Zyq JZWQZ8NU4ds= -----END CERTIFICATE----- -----BEGIN CERTIFICATE----- MIIHyTCCBbGgAwIBAgIBATANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJJTDEW MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM2WhcNMzYwOTE3MTk0NjM2WjB9 MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w +2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B 26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID AQABo4ICUjCCAk4wDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAa4wHQYDVR0OBBYE FE4L7xqkQFulF2mHMMo0aEPQQa7yMGQGA1UdHwRdMFswLKAqoCiGJmh0dHA6Ly9j ZXJ0LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMCugKaAnhiVodHRwOi8vY3Js LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMIIBXQYDVR0gBIIBVDCCAVAwggFM BgsrBgEEAYG1NwEBATCCATswLwYIKwYBBQUHAgEWI2h0dHA6Ly9jZXJ0LnN0YXJ0 Y29tLm9yZy9wb2xpY3kucGRmMDUGCCsGAQUFBwIBFilodHRwOi8vY2VydC5zdGFy dGNvbS5vcmcvaW50ZXJtZWRpYXRlLnBkZjCB0AYIKwYBBQUHAgIwgcMwJxYgU3Rh cnQgQ29tbWVyY2lhbCAoU3RhcnRDb20pIEx0ZC4wAwIBARqBl0xpbWl0ZWQgTGlh YmlsaXR5LCByZWFkIHRoZSBzZWN0aW9uICpMZWdhbCBMaW1pdGF0aW9ucyogb2Yg dGhlIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFBvbGljeSBhdmFp bGFibGUgYXQgaHR0cDovL2NlcnQuc3RhcnRjb20ub3JnL3BvbGljeS5wZGYwEQYJ YIZIAYb4QgEBBAQDAgAHMDgGCWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNT TCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTANBgkqhkiG9w0BAQUFAAOCAgEAFmyZ 9GYMNPXQhV59CuzaEE44HF7fpiUFS5Eyweg78T3dRAlbB0mKKctmArexmvclmAk8 jhvh3TaHK0u7aNM5Zj2gJsfyOZEdUauCe37Vzlrk4gNXcGmXCPleWKYK34wGmkUW FjgKXlf2Ysd6AgXmvB618p70qSmD+LIU424oh0TDkBreOKk8rENNZEXO3SipXPJz ewT4F+irsfMuXGRuczE6Eri8sxHkfY+BUZo7jYn0TZNmezwD7dOaHZrzZVD1oNB1 ny+v8OqCQ5j4aZyJecRDjkZy42Q2Eq/3JR44iZB3fsNrarnDy0RLrHiQi+fHLB5L EUTINFInzQpdn4XBidUaePKVEFMy3YCEZnXZtWgo+2EuvoSoOMCZEoalHmdkrQYu L6lwhceWD3yJZfWOQ1QOq92lgDmUYMA0yZZwLKMS9R9Ie70cfmu3nZD0Ijuu+Pwq yvqCUqDvr0tVk+vBtfAii6w0TiYiBKGHLHVKt+V9E9e4DGTANtLJL4YSjCMJwRuC O3NJo2pXh5Tl1njFmUNj403gdy3hZZlyaQQaRwnmDwFWJPsfvw55qVguucQJAX6V um0ABj6y6koQOdjQK/W/7HW/lwLFCRsI3FU34oH7N4RDYiDK51ZLZer+bMEkkySh NOsF/5oirpt9P/FlUQqmMGqz9IgcgA38corog14= -----END CERTIFICATE-----'''

gpl-3.0

dirn/readthedocs.org

readthedocs/restapi/permissions.py

12

1615

from rest_framework import permissions from privacy.backend import AdminPermission class IsOwner(permissions.BasePermission): """ Custom permission to only allow owners of an object to edit it. """ def has_object_permission(self, request, view, obj): # Write permissions are only allowed to the owner of the snippet return request.user in obj.users.all() class CommentModeratorOrReadOnly(permissions.BasePermission): def has_object_permission(self, request, view, comment): if request.method in permissions.SAFE_METHODS: return True # TODO: Similar logic to #1084 else: return AdminPermission.is_admin(request.user, comment.node.project) class RelatedProjectIsOwner(permissions.BasePermission): """ Custom permission to only allow owners of an object to edit it. """ def has_object_permission(self, request, view, obj): # Write permissions are only allowed to the owner of the snippet return request.user in obj.project.users.all() class APIPermission(permissions.IsAuthenticatedOrReadOnly): ''' This permission should allow authenicated users readonly access to the API, and allow admin users write access. This should be used on API resources that need to implement write operations to resources that were based on the ReadOnlyViewSet ''' def has_object_permission(self, request, view, obj): has_perm = super(APIPermission, self).has_object_permission( request, view, obj) return has_perm or (request.user and request.user.is_staff)

mit

tomprince/alot

alot/ui.py

1

17916

import urwid import logging from twisted.internet import reactor, defer from twisted.python.failure import Failure from settings import config from buffers import BufferlistBuffer import commands from commands import commandfactory from alot.commands import CommandParseError import widgets class InputWrap(urwid.WidgetWrap): """ This is the topmost widget used in the widget tree. Its purpose is to capture and interpret keypresses by instantiating and applying the relevant :class:`Command` objects or relaying them to the wrapped `rootwidget`. """ def __init__(self, ui, rootwidget): urwid.WidgetWrap.__init__(self, rootwidget) self.ui = ui self.rootwidget = rootwidget self.select_cancel_only = False def set_root(self, w): self._w = w def get_root(self): return self._w def allowed_command(self, cmd): """sanity check if the given command should be applied. This is used in :meth:`keypress`""" if not self.select_cancel_only: return True elif isinstance(cmd, commands.globals.SendKeypressCommand): if cmd.key in ['select', 'cancel']: return True else: return False def keypress(self, size, key): """overwrites `urwid.WidgetWrap.keypress`""" mode = self.ui.mode if self.select_cancel_only: mode = 'global' cmdline = config.get_mapping(mode, key) if cmdline: try: cmd = commandfactory(cmdline, mode) if self.allowed_command(cmd): self.ui.apply_command(cmd) return None except CommandParseError, e: self.ui.notify(e.message, priority='error') return self._w.keypress(size, key) class UI(object): """ This class integrates all components of alot and offers methods for user interaction like :meth:`prompt`, :meth:`notify` etc. It handles the urwid widget tree and mainloop (we use twisted) and is responsible for opening, closing and focussing buffers. """ buffers = [] """list of active buffers""" current_buffer = None """points to currently active :class:`~alot.buffers.Buffer`""" dbman = None """Database manager (:class:`~alot.db.DBManager`)""" accountman = None """account manager (:class:`~alot.account.AccountManager`)""" def __init__(self, dbman, accountman, initialcmd, colourmode): """ :param dbman: :class:`~alot.db.DBManager` :param accountman: :class:`~alot.account.AccountManager` :param initialcmd: commandline applied after setting up interface :type initialcmd: str :param colourmode: determines which theme to chose :type colourmode: int in [1,16,256] """ self.dbman = dbman self.accountman = accountman if not colourmode: colourmode = config.getint('general', 'colourmode') logging.info('setup gui in %d colours' % colourmode) self.mainframe = urwid.Frame(urwid.SolidFill()) self.inputwrap = InputWrap(self, self.mainframe) self.mainloop = urwid.MainLoop(self.inputwrap, config.get_palette(), handle_mouse=False, event_loop=urwid.TwistedEventLoop(), unhandled_input=self.unhandeled_input) self.mainloop.screen.set_terminal_properties(colors=colourmode) self.show_statusbar = config.getboolean('general', 'show_statusbar') self.notificationbar = None self.mode = 'global' self.commandprompthistory = [] logging.debug('fire first command') self.apply_command(initialcmd) self.mainloop.run() def unhandeled_input(self, key): """called if a keypress is not handled.""" logging.debug('unhandled input: %s' % key) def keypress(self, key): """relay all keypresses to our `InputWrap`""" self.inputwrap.keypress((150, 20), key) def show_as_root_until_keypress(self, w, key, relay_rest=True, afterwards=None): def oe(): self.inputwrap.set_root(self.mainframe) self.inputwrap.select_cancel_only = False if callable(afterwards): logging.debug('called') afterwards() logging.debug('relay: %s' % relay_rest) helpwrap = widgets.CatchKeyWidgetWrap(w, key, on_catch=oe, relay_rest=relay_rest) self.inputwrap.set_root(helpwrap) self.inputwrap.select_cancel_only = not relay_rest def prompt(self, prefix='>', text=u'', completer=None, tab=0, history=[]): """prompt for text input :param prefix: text to print before the input field :type prefix: str :param text: initial content of the input field :type text: str :param completer: completion object to use :type completer: :meth:`alot.completion.Completer` :param tab: number of tabs to press initially (to select completion results) :type tab: int :param history: history to be used for up/down keys :type history: list of str :returns: a :class:`twisted.defer.Deferred` """ d = defer.Deferred() # create return deferred oldroot = self.inputwrap.get_root() def select_or_cancel(text): # restore main screen and invoke callback # (delayed return) with given text self.inputwrap.set_root(oldroot) self.inputwrap.select_cancel_only = False d.callback(text) #set up widgets leftpart = urwid.Text(prefix, align='left') editpart = widgets.CompleteEdit(completer, on_exit=select_or_cancel, edit_text=text, history=history) for i in range(tab): # hit some tabs editpart.keypress((0,), 'tab') # build promptwidget both = urwid.Columns( [ ('fixed', len(prefix), leftpart), ('weight', 1, editpart), ]) both = urwid.AttrMap(both, 'global_prompt') # put promptwidget as overlay on main widget overlay = urwid.Overlay(both, oldroot, ('fixed left', 0), ('fixed right', 0), ('fixed bottom', 1), None) self.inputwrap.set_root(overlay) self.inputwrap.select_cancel_only = True return d # return deferred def exit(self): """ shuts down user interface without cleaning up. Use a :class:`commands.globals.ExitCommand` for a clean shutdown. """ reactor.stop() def buffer_open(self, buf): """register and focus new :class:`~alot.buffers.Buffer`.""" self.buffers.append(buf) self.buffer_focus(buf) def buffer_close(self, buf): """ closes given :class:`~alot.buffers.Buffer`. This it removes it from the bufferlist and calls its cleanup() method. """ buffers = self.buffers if buf not in buffers: string = 'tried to close unknown buffer: %s. \n\ni have:%s' logging.error(string % (buf, self.buffers)) elif self.current_buffer == buf: logging.debug('UI: closing current buffer %s' % buf) index = buffers.index(buf) buffers.remove(buf) offset = config.getint('general', 'bufferclose_focus_offset') nextbuffer = buffers[(index + offset) % len(buffers)] self.buffer_focus(nextbuffer) buf.cleanup() else: string = 'closing buffer %d:%s' logging.debug(string % (buffers.index(buf), buf)) buffers.remove(buf) buf.cleanup() def buffer_focus(self, buf): """focus given :class:`~alot.buffers.Buffer`.""" if buf not in self.buffers: logging.error('tried to focus unknown buffer') else: if self.current_buffer != buf: self.current_buffer = buf self.inputwrap.set_root(self.mainframe) self.mode = buf.modename if isinstance(self.current_buffer, BufferlistBuffer): self.current_buffer.rebuild() self.update() def get_deep_focus(self, startfrom=None): """return the bottom most focussed widget of the widget tree""" if not startfrom: startfrom = self.current_buffer if 'get_focus' in dir(startfrom): focus = startfrom.get_focus() if isinstance(focus, tuple): focus = focus[0] if isinstance(focus, urwid.Widget): return self.get_deep_focus(startfrom=focus) return startfrom def get_buffers_of_type(self, t): """ returns currently open buffers for a given subclass of :class:`alot.buffer.Buffer` """ return filter(lambda x: isinstance(x, t), self.buffers) def clear_notify(self, messages): """ clears notification popups. Call this to ged rid of messages that don't time out. :param messages: The popups to remove. This should be exactly what :meth:`notify` returned when creating the popup """ newpile = self.notificationbar.widget_list for l in messages: newpile.remove(l) if newpile: self.notificationbar = urwid.Pile(newpile) else: self.notificationbar = None self.update() def choice(self, message, choices={'y': 'yes', 'n': 'no'}, select=None, cancel=None, msg_position='above'): """ prompt user to make a choice :param message: string to display before list of choices :type message: unicode :param choices: dict of possible choices :type choices: dict: keymap->choice (both str) :param select: choice to return if enter/return is hit. Ignored if set to `None`. :type select: str :param cancel: choice to return if escape is hit. Ignored if set to `None`. :type cancel: str :param msg_position: determines if `message` is above or left of the prompt. Must be `above` or `left`. :type msg_position: str :returns: a :class:`twisted.defer.Deferred` """ assert select in choices.values() + [None] assert cancel in choices.values() + [None] assert msg_position in ['left', 'above'] d = defer.Deferred() # create return deferred oldroot = self.inputwrap.get_root() def select_or_cancel(text): self.inputwrap.set_root(oldroot) self.inputwrap.select_cancel_only = False d.callback(text) #set up widgets msgpart = urwid.Text(message) choicespart = widgets.ChoiceWidget(choices, callback=select_or_cancel, select=select, cancel=cancel) # build widget if msg_position == 'left': both = urwid.Columns( [ ('fixed', len(message), msgpart), ('weight', 1, choicespart), ], dividechars=1) else: # above both = urwid.Pile([msgpart, choicespart]) both = urwid.AttrMap(both, 'prompt', 'prompt') # put promptwidget as overlay on main widget overlay = urwid.Overlay(both, oldroot, ('fixed left', 0), ('fixed right', 0), ('fixed bottom', 1), None) self.inputwrap.set_root(overlay) self.inputwrap.select_cancel_only = True return d # return deferred def notify(self, message, priority='normal', timeout=0, block=False): """ opens notification popup :param message: message to print :type message: str :param priority: priority string, used to format the popup: currently, 'normal' and 'error' are defined. If you use 'X' here, the attribute 'global_notify_X' is used to format the popup. :type priority: str :param timeout: seconds until message disappears. Defaults to the value of 'notify_timeout' in the general config section. A negative value means never time out. :type timeout: int :param block: this notification blocks until a keypress is made :type block: bool :returns: an urwid widget (this notification) that can be handed to :meth:`clear_notify` for removal """ def build_line(msg, prio): cols = urwid.Columns([urwid.Text(msg)]) return urwid.AttrMap(cols, 'global_notify_' + prio) msgs = [build_line(message, priority)] if not self.notificationbar: self.notificationbar = urwid.Pile(msgs) else: newpile = self.notificationbar.widget_list + msgs self.notificationbar = urwid.Pile(newpile) self.update() def clear(*args): self.clear_notify(msgs) if block: # put "cancel to continue" widget as overlay on main widget txt = urwid.Text('(cancel continues)') overlay = urwid.Overlay(txt, self.mainframe, ('fixed left', 0), ('fixed right', 0), ('fixed bottom', 0), None) self.show_as_root_until_keypress(overlay, 'cancel', relay_rest=False, afterwards=clear) else: if timeout >= 0: if timeout == 0: timeout = config.getint('general', 'notify_timeout') self.mainloop.set_alarm_in(timeout, clear) return msgs[0] def update(self): """redraw interface""" #who needs a header? #head = urwid.Text('notmuch gui') #h=urwid.AttrMap(head, 'header') #self.mainframe.set_header(h) # body if self.current_buffer: self.mainframe.set_body(self.current_buffer) # footer lines = [] if self.notificationbar: # .get_text()[0] != ' ': lines.append(self.notificationbar) if self.show_statusbar: lines.append(self.build_statusbar()) if lines: self.mainframe.set_footer(urwid.Pile(lines)) else: self.mainframe.set_footer(None) def build_statusbar(self): """construct and return statusbar widget""" if self.current_buffer is not None: idx = self.buffers.index(self.current_buffer) lefttxt = '%d: %s' % (idx, self.current_buffer) else: lefttxt = '[no buffers]' footerleft = urwid.Text(lefttxt, align='left') righttxt = 'total messages: %d' % self.dbman.count_messages('*') pending_writes = len(self.dbman.writequeue) if pending_writes > 0: righttxt = ('|' * pending_writes) + ' ' + righttxt footerright = urwid.Text(righttxt, align='right') columns = urwid.Columns([ footerleft, ('fixed', len(righttxt), footerright)]) return urwid.AttrMap(columns, 'global_footer') def apply_command(self, cmd): """ applies a command This calls the pre and post hooks attached to the command, as well as :meth:`cmd.apply`. :param cmd: an applicable command :type cmd: :class:`~alot.commands.Command` """ if cmd: # call pre- hook if cmd.prehook: logging.debug('calling pre-hook') try: cmd.prehook(ui=self, dbm=self.dbman, aman=self.accountman, config=config) except: logging.exception('prehook failed') # define (callback) function that invokes post-hook def call_posthook(retval_from_apply): if cmd.posthook: logging.debug('calling post-hook') try: cmd.posthook(ui=self, dbm=self.dbman, aman=self.accountman, config=config) except: logging.exception('posthook failed') # define error handler for Failures/Exceptions # raised in cmd.apply() def errorHandler(failure): logging.debug(failure.getTraceback()) msg = "Error: %s,\ncheck the log for details" self.notify(msg % failure.getErrorMessage(), priority='error') # call cmd.apply logging.debug('apply command: %s' % cmd) try: retval = cmd.apply(self) # if we deal with a InlineCallbacks-decorated method, it # instantly returns a defered. This adds call/errbacks to react # to successful/erroneous termination of the defered apply() if isinstance(retval, defer.Deferred): retval.addErrback(errorHandler) retval.addCallback(call_posthook) except Exception, e: errorHandler(Failure(e))

gpl-3.0

tsgit/invenio

modules/websession/lib/websession_regression_tests.py

8

5312

# -*- coding: utf-8 -*- ## ## This file is part of Invenio. ## Copyright (C) 2006, 2007, 2008, 2010, 2011, 2014 CERN. ## ## Invenio is free software; you can redistribute it and/or ## modify it under the terms of the GNU General Public License as ## published by the Free Software Foundation; either version 2 of the ## License, or (at your option) any later version. ## ## Invenio 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 ## General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with Invenio; if not, write to the Free Software Foundation, Inc., ## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. # pylint: disable=E1102 """WebSession Regression Test Suite.""" __revision__ = \ "$Id$" from invenio.testutils import InvenioTestCase from mechanize import Browser from invenio.config import CFG_SITE_SECURE_URL, CFG_SITE_ADMIN_EMAIL from invenio.testutils import make_test_suite, run_test_suite, \ test_web_page_content, merge_error_messages from invenio.dbquery import run_sql class WebSessionWebPagesAvailabilityTest(InvenioTestCase): """Check WebSession web pages whether they are up or not.""" def test_your_account_pages_availability(self): """websession - availability of Your Account pages""" baseurl = CFG_SITE_SECURE_URL + '/youraccount/' # not testing 'change' endpoint here, since it is accepting # only POST requests _exports = ['', 'edit', 'lost', 'display', 'send_email', 'youradminactivities', 'delete', 'logout', 'login', 'register'] error_messages = [] for url in [baseurl + page for page in _exports]: error_messages.extend(test_web_page_content(url)) if error_messages: self.fail(merge_error_messages(error_messages)) return def test_your_groups_pages_availability(self): """websession - availability of Your Groups pages""" baseurl = CFG_SITE_SECURE_URL + '/yourgroups/' _exports = ['', 'display', 'create', 'join', 'leave', 'edit', 'members'] error_messages = [] for url in [baseurl + page for page in _exports]: error_messages.extend(test_web_page_content(url)) if error_messages: self.fail(merge_error_messages(error_messages)) return class WebSessionLostYourPasswordTest(InvenioTestCase): """Test Lost Your Passwords functionality.""" def test_lost_your_password_for_internal_accounts(self): """websession - sending lost password for internal admin account""" try_with_account = CFG_SITE_ADMIN_EMAIL # click on "send lost password" for CFG_SITE_ADMIN_EMAIL internal account browser = Browser() browser.open(CFG_SITE_SECURE_URL + "/youraccount/lost") browser.select_form(nr=0) browser['p_email'] = try_with_account try: browser.submit() except Exception, e: # Restore the admin password (send_email set it to random number) run_sql("UPDATE user SET password=AES_ENCRYPT(email, '')" "WHERE id=1") self.fail("Obtained %s: probably the email server is not installed " "correctly." % e) # verify the response: expected_response = "Okay, a password reset link has been emailed to " + \ try_with_account lost_password_response_body = browser.response().read() try: lost_password_response_body.index(expected_response) except ValueError: # Restore the admin password (send_email set it to random number) run_sql("UPDATE user SET password=AES_ENCRYPT(email, '')" "WHERE id=1") self.fail("Expected to see %s, got %s." % \ (expected_response, lost_password_response_body)) def tearDown(self): # Restore the admin password (send_email set it to random number) run_sql("UPDATE user SET password=AES_ENCRYPT(email, '')" "WHERE id=1") class WebSessionExternalLoginTest(InvenioTestCase): """Test external login functionality.""" def test_no_external_login(self): """websession - openid, oauth1 or oauth2 external login option in log in page""" base_url = CFG_SITE_SECURE_URL + '/youraccount' login_url = base_url + '/login' browser = Browser() response = browser.open(login_url) #Check all the links and see if any of them is of class openid (external login button) for link in browser.links(): for value in link.attrs: if (value[0] == 'class'): if value[1] == 'openid_url': self.fail("Openid external login in login page: %s" % link.attrs) return TEST_SUITE = make_test_suite(WebSessionWebPagesAvailabilityTest, WebSessionLostYourPasswordTest, WebSessionExternalLoginTest) if __name__ == "__main__": run_test_suite(TEST_SUITE, warn_user=True)

gpl-2.0

xyzy/androguard

tests/test_ins.py

38

5384

#!/usr/bin/env python # This file is part of Androguard. # # Copyright (C) 2012, Anthony Desnos <desnos at t0t0.fr> # All rights reserved. # # Androguard 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. # # Androguard 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 Androguard. If not, see <http://www.gnu.org/licenses/>. import sys, re PATH_INSTALL = "./" sys.path.append(PATH_INSTALL) from androguard.core.androgen import AndroguardS from androguard.core.analysis import analysis TESTS_CASES = [ #'examples/android/TC/bin/classes.dex', 'examples/android/TestsAndroguard/bin/classes.dex', ] VALUES = { 'examples/android/TestsAndroguard/bin/classes.dex' : { "Ltests/androguard/TestInvoke; <init> ()V" : { 0x0 : ("invoke-direct" , [['v',1] , ['meth@', 4, 'Ljava/lang/Object;', '()', 'V', '<init>']]), 0xa : ("invoke-virtual", [['v',1], ['v',0] , ['meth@', 49, 'Ltests/androguard/TestInvoke;', '(I)', 'I', 'TestInvoke1']]), }, "Ltests/androguard/TestInvoke; TestInvoke1 (I)I" : { 0x4 : ("invoke-virtual", [['v',1] , ['v',2] , ['v',0] , ['meth@', 50,'Ltests/androguard/TestInvoke;' ,'(I I)', 'I', 'TestInvoke2']]), }, "Ltests/androguard/TestInvoke; TestInvoke2 (I I)I" : { 0x4 : ("invoke-virtual", [['v',1] , ['v',2] , ['v',3] , ['v',0] , ['meth@', 51, 'Ltests/androguard/TestInvoke;', '(I I I)', 'I', 'TestInvoke3']]), }, "Ltests/androguard/TestInvoke; TestInvoke3 (I I I)I" : { 0x4 : ("invoke-virtual", [['v', 1], ['v', 2], ['v', 3], ['v', 4], ['v', 0], ['meth@', 52, 'Ltests/androguard/TestInvoke;', '(I I I I)', 'I', 'TestInvoke4']]), }, "Ltests/androguard/TestInvoke; TestInvoke4 (I I I I)I" : { 0xe : ("invoke-virtual/range", [['v', 0], ['v', 1], ['v', 2], ['v', 3], ['v', 4], ['v', 5], ['meth@', 53, 'Ltests/androguard/TestInvoke;', '(I I I I I)', 'I', 'TestInvoke5']]), }, "Ltests/androguard/TestInvoke; TestInvoke5 (I I I I I)I" : { 0x10 : ("invoke-virtual/range", [['v', 0], ['v', 1], ['v', 2], ['v', 3], ['v', 4], ['v', 5], ['v', 6], ['meth@', 54, 'Ltests/androguard/TestInvoke;', '(I I I I I I)', 'I', 'TestInvoke6']]), }, "Ltests/androguard/TestInvoke; TestInvoke6 (I I I I I I)I" : { 0x12 : ("invoke-virtual/range", [['v', 0], ['v', 1], ['v', 2], ['v', 3], ['v', 4], ['v', 5], ['v', 6], ['v', 7], ['meth@', 55, 'Ltests/androguard/TestInvoke;', '(I I I I I I I)', 'I', 'TestInvoke7']]), }, "Ltests/androguard/TestInvoke; TestInvoke7 (I I I I I I I)I" : { 0x16 : ("invoke-virtual/range", [['v', 0], ['v', 1], ['v', 2], ['v', 3], ['v', 4], ['v', 5], ['v', 6], ['v', 7], ['v', 8], ['meth@', 56, 'Ltests/androguard/TestInvoke;', '(I I I I I I I I)', 'I', 'TestInvoke8']]), }, "Ltests/androguard/TestInvoke; TestInvoke8 (I I I I I I I I)I" : { 0x0 : ("mul-int", [['v', 0], ['v', 2], ['v', 3]]), 0x4 : ("mul-int/2addr", [['v', 0], ['v', 4]]), 0x10 : ("return", [['v', 0]]), } }, } def test(got, expected): if got == expected: prefix = ' OK ' else: prefix = ' X ' print '\t%s got: %s expected: %s' % (prefix, repr(got), repr(expected)) def getVal(i) : op = i.get_operands() if isinstance(op, int) : return [ op ] elif i.get_name() == "lookupswitch" : x = [] x.append( i.get_operands().default ) for idx in range(0, i.get_operands().npairs) : off = getattr(i.get_operands(), "offset%d" % idx) x.append( off ) return x return [-1] def check(a, values) : for method in a.get_methods() : key = method.get_class_name() + " " + method.get_name() + " " + method.get_descriptor() if key not in values : continue print "CHECKING ...", method.get_class_name(), method.get_name(), method.get_descriptor() code = method.get_code() bc = code.get_bc() idx = 0 for i in bc.get() : # print "\t", "%x(%d)" % (idx, idx), i.get_name(), i.get_operands() if idx in values[key] : elem = values[key][idx] val1 = i.get_name() + "%s" % i.get_operands() val2 = elem[0] + "%s" % elem[1] test(val1, val2) del values[key][idx] idx += i.get_length() for i in TESTS_CASES : a = AndroguardS( i ) check( a, VALUES[i] ) x = analysis.VMAnalysis( a.get_vm() ) print x

apache-2.0

devilry/devilry-django

devilry/apps/core/tests/test_assignment_group_history.py

1

8857

from django.test import TestCase from django.utils import timezone from django.utils.timezone import timedelta from model_bakery import baker from devilry.apps.core import devilry_core_baker_factories as core_baker from devilry.apps.core.models import AssignmentGroup from devilry.apps.core.models import AssignmentGroupHistory from devilry.devilry_dbcache.customsql import AssignmentGroupDbCacheCustomSql class TestAssignmentGroupHistory(TestCase): def setUp(self): AssignmentGroupDbCacheCustomSql().initialize() def test_merge_history_meta_data(self): assignment_group_history = baker.make('core.AssignmentGroupHistory') datetime1 = (timezone.now() - timedelta(days=1)).isoformat() datetime2 = (timezone.now() - timedelta(days=2)).isoformat() assignment_group_history.merge_history = { 'merge_datetime': datetime1, 'state': None, 'groups': [ { 'merge_datetime': datetime2, 'state': { 'name': 'group1' }, 'groups': [ { 'merge_datetime': None, 'state': { 'name': 'group1' }, 'groups': [] }, { 'merge_datetime': None, 'state': { 'name': 'group3' }, 'groups': [] }, { 'merge_datetime': None, 'state': { 'name': 'group4' }, 'groups': [] } ] }, { 'merge_datetime': None, 'state': { 'name': 'group2' }, 'groups': [] } ] } meta_data = assignment_group_history.meta_data self.assertEqual(len(meta_data), 2) self.assertDictEqual(meta_data[0], { 'merge_datetime': datetime1, 'groups': ['group1', 'group2'] }) self.assertDictEqual(meta_data[1], { 'merge_datetime': datetime2, 'groups': ['group1', 'group3', 'group4'] }) def test_merge_history_meta_data_real_groups(self): test_assignment = baker.make_recipe('devilry.apps.core.assignment_activeperiod_start') group1 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group1') group2 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group2') group3 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group3') group4 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group4') AssignmentGroup.merge_groups([group1, group2, group3]) AssignmentGroup.merge_groups([group1, group4]) meta_data = AssignmentGroupHistory.objects.get(assignment_group__id=group1.id).meta_data self.assertEqual(len(meta_data), 2) self.assertDictContainsSubset({ 'groups': ['group1', 'group4'] }, meta_data[0]) self.assertDictContainsSubset({ 'groups': ['group1', 'group2', 'group3'] }, meta_data[1]) def test_merge_single_assignment_groups(self): test_assignment = baker.make_recipe('devilry.apps.core.assignment_activeperiod_start') group1 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group1') group2 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group2') AssignmentGroup.merge_groups([group1, group2]) merge_history = AssignmentGroupHistory.objects.get(assignment_group__id=group1.id).merge_history self.assertEqual(merge_history['groups'][0]['state']['name'], 'group1') self.assertEqual(merge_history['groups'][1]['state']['name'], 'group2') def test_merge_assignmentgroup_multiple_times(self): test_assignment = baker.make_recipe('devilry.apps.core.assignment_activeperiod_start') group1 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group1') group2 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group2') group3 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group3') group4 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group4') core_baker.candidate(group=group1) core_baker.candidate(group=group1) core_baker.candidate(group=group2) core_baker.candidate(group=group3) core_baker.candidate(group=group4) core_baker.examiner(group=group1) core_baker.examiner(group=group2) core_baker.examiner(group=group2) core_baker.examiner(group=group3) group1_state = group1.get_current_state() group2_state = group2.get_current_state() group3_state = group3.get_current_state() group4_state = group4.get_current_state() AssignmentGroup.merge_groups([group1, group3]) AssignmentGroup.merge_groups([group2, group4]) group1_merge_history = AssignmentGroupHistory.objects.get(assignment_group__id=group1.id).merge_history group2_merge_history = AssignmentGroupHistory.objects.get(assignment_group__id=group2.id).merge_history self.assertDictEqual(group1_merge_history['groups'][0]['state'], group1_state) self.assertDictEqual(group1_merge_history['groups'][1]['state'], group3_state) self.assertDictEqual(group2_merge_history['groups'][0]['state'], group2_state) self.assertDictEqual(group2_merge_history['groups'][1]['state'], group4_state) group1 = AssignmentGroup.objects.get(id=group1.id) group2 = AssignmentGroup.objects.get(id=group2.id) # Checking one more level in the Btree group1_state = AssignmentGroup.objects.get(id=group1.id).get_current_state() group2_state = AssignmentGroup.objects.get(id=group2.id).get_current_state() AssignmentGroup.merge_groups([group1, group2]) group1_merge_history_new = AssignmentGroupHistory.objects.get(assignment_group__id=group1.id).merge_history self.assertListEqual(group1_merge_history_new['groups'][0]['groups'], group1_merge_history['groups']) self.assertListEqual(group1_merge_history_new['groups'][1]['groups'], group2_merge_history['groups']) self.assertDictEqual(group1_merge_history_new['groups'][0]['state'], group1_state) self.assertDictEqual(group1_merge_history_new['groups'][1]['state'], group2_state) def test_is_deleted_after_merge(self): test_assignment = baker.make_recipe('devilry.apps.core.assignment_activeperiod_start') group1 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group1') group2 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group2') group3 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group3') group4 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group4') AssignmentGroup.merge_groups([group1, group2]) historygroup1id = group1.assignmentgrouphistory.id AssignmentGroup.merge_groups([group4, group3]) historygroup4id = group4.assignmentgrouphistory.id AssignmentGroup.merge_groups([group1, group4]) with self.assertRaises(AssignmentGroupHistory.DoesNotExist): AssignmentGroupHistory.objects.get(id=historygroup4id) self.assertTrue(AssignmentGroupHistory.objects.filter(id=historygroup1id).exists()) # def test_num_queries(self): # test_assignment = baker.make_recipe('devilry.apps.core.assignment_activeperiod_start') # group1 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group1') # group2 = baker.make('core.AssignmentGroup', parentnode=test_assignment, name='group2') # group_baker.feedbackset_new_attempt_published(group1) # group_baker.feedbackset_new_attempt_published(group1) # group_baker.feedbackset_new_attempt_published(group2) # group_baker.feedbackset_new_attempt_published(group2) # # with self.assertNumQueries(3): # AssignmentGroup.merge_groups([group1, group2])

bsd-3-clause

ichuang/sympy

sympy/stats/tests/test_continuous_rv.py

1

14252

from sympy.stats import (P, E, where, density, variance, covariance, skewness, given, pspace, cdf, ContinuousRV, sample) from sympy.stats import (Arcsin, Benini, Beta, BetaPrime, Cauchy, Chi, Dagum, Exponential, Gamma, Laplace, Logistic, LogNormal, Maxwell, Nakagami, Normal, Pareto, Rayleigh, StudentT, Triangular, Uniform, UniformSum, Weibull, WignerSemicircle) from sympy import (Symbol, Dummy, Abs, exp, S, N, pi, simplify, Interval, erf, Eq, log, lowergamma, Sum, symbols, sqrt, And, gamma, beta, Piecewise, Integral, sin, Lambda, factorial, binomial, floor) from sympy.utilities.pytest import raises, XFAIL oo = S.Infinity _x = Dummy("x") _z = Dummy("z") def test_single_normal(): mu = Symbol('mu', real=True, bounded=True) sigma = Symbol('sigma', real=True, positive=True, bounded=True) X = Normal(0,1) Y = X*sigma + mu assert simplify(E(Y)) == mu assert simplify(variance(Y)) == sigma**2 pdf = density(Y) x = Symbol('x') assert pdf(x) == 2**S.Half*exp(-(x - mu)**2/(2*sigma**2))/(2*pi**S.Half*sigma) assert P(X**2 < 1) == erf(2**S.Half/2) assert E(X, Eq(X, mu)) == mu @XFAIL def test_conditional_1d(): X = Normal(0,1) Y = given(X, X>=0) assert density(Y) == 2 * density(X) assert Y.pspace.domain.set == Interval(0, oo) assert E(Y) == sqrt(2) / sqrt(pi) assert E(X**2) == E(Y**2) def test_ContinuousDomain(): X = Normal(0,1) assert where(X**2<=1).set == Interval(-1,1) assert where(X**2<=1).symbol == X.symbol where(And(X**2<=1, X>=0)).set == Interval(0,1) raises(ValueError, "where(sin(X)>1)") Y = given(X, X>=0) assert Y.pspace.domain.set == Interval(0, oo) def test_multiple_normal(): X, Y = Normal(0,1), Normal(0,1) assert E(X+Y) == 0 assert variance(X+Y) == 2 assert variance(X+X) == 4 assert covariance(X, Y) == 0 assert covariance(2*X + Y, -X) == -2*variance(X) assert E(X, Eq(X+Y, 0)) == 0 assert variance(X, Eq(X+Y, 0)) == S.Half def test_symbolic(): mu1, mu2 = symbols('mu1 mu2', real=True, bounded=True) s1, s2 = symbols('sigma1 sigma2', real=True, bounded=True, positive=True) rate = Symbol('lambda', real=True, positive=True, bounded=True) X = Normal(mu1, s1) Y = Normal(mu2, s2) Z = Exponential(rate) a, b, c = symbols('a b c', real=True, bounded=True) assert E(X) == mu1 assert E(X+Y) == mu1+mu2 assert E(a*X+b) == a*E(X)+b assert variance(X) == s1**2 assert simplify(variance(X+a*Y+b)) == variance(X) + a**2*variance(Y) assert E(Z) == 1/rate assert E(a*Z+b) == a*E(Z)+b assert E(X+a*Z+b) == mu1 + a/rate + b def test_cdf(): X = Normal(0,1) d = cdf(X) assert P(X<1) == d(1) assert d(0) == S.Half d = cdf(X, X>0) # given X>0 assert d(0) == 0 Y = Exponential(10) d = cdf(Y) assert d(-5) == 0 assert P(Y > 3) == 1 - d(3) raises(ValueError, "cdf(X+Y)") Z = Exponential(1) f = cdf(Z) z = Symbol('z') assert f(z) == Piecewise((0, z < 0), (1 - exp(-z), True)) def test_sample(): z = Symbol('z') Z = ContinuousRV(z, exp(-z), set=Interval(0,oo)) assert sample(Z) in Z.pspace.domain.set sym, val = Z.pspace.sample().items()[0] assert sym == Z and val in Interval(0, oo) def test_ContinuousRV(): x = Symbol('x') pdf = sqrt(2)*exp(-x**2/2)/(2*sqrt(pi)) # Normal distribution # X and Y should be equivalent X = ContinuousRV(x, pdf) Y = Normal(0, 1) assert variance(X) == variance(Y) assert P(X>0) == P(Y>0) def test_arcsin(): a = Symbol("a", real=True) b = Symbol("b", real=True) x = Symbol("x") X = Arcsin(a, b, symbol=x) assert density(X) == Lambda(_x, 1/(pi*sqrt((-_x + b)*(_x - a)))) def test_benini(): alpha = Symbol("alpha", positive=True) b = Symbol("beta", positive=True) sigma = Symbol("sigma", positive=True) x = Symbol("x") X = Benini(alpha, b, sigma, symbol=x) assert density(X) == (Lambda(_x, (alpha/_x + 2*b*log(_x/sigma)/_x) *exp(-alpha*log(_x/sigma) - b*log(_x/sigma)**2))) def test_beta(): a, b = symbols('alpha beta', positive=True) B = Beta(a, b) assert pspace(B).domain.set == Interval(0, 1) dens = density(B) x = Symbol('x') assert dens(x) == x**(a-1)*(1-x)**(b-1) / beta(a,b) # This is too slow # assert E(B) == a / (a + b) # assert variance(B) == (a*b) / ((a+b)**2 * (a+b+1)) # Full symbolic solution is too much, test with numeric version a, b = 1, 2 B = Beta(a, b) assert E(B) == a / S(a + b) assert variance(B) == (a*b) / S((a+b)**2 * (a+b+1)) def test_betaprime(): alpha = Symbol("alpha", positive=True) beta = Symbol("beta", positive=True) x = Symbol("x") X = BetaPrime(alpha, beta, symbol=x) assert density(X) == (Lambda(_x, _x**(alpha - 1)*(_x + 1)**(-alpha - beta) *gamma(alpha + beta)/(gamma(alpha)*gamma(beta)))) def test_cauchy(): x0 = Symbol("x0") gamma = Symbol("gamma", positive=True) x = Symbol("x") X = Cauchy(x0, gamma, symbol=x) assert density(X) == Lambda(_x, 1/(pi*gamma*(1 + (_x - x0)**2/gamma**2))) def test_chi(): k = Symbol("k", integer=True) x = Symbol("x") X = Chi(k, symbol=x) assert density(X) == (Lambda(_x, 2**(-k/2 + 1)*_x**(k - 1) *exp(-_x**2/2)/gamma(k/2))) def test_dagum(): p = Symbol("p", positive=True) b = Symbol("b", positive=True) a = Symbol("a", positive=True) x = Symbol("x") X = Dagum(p, a, b, symbol=x) assert density(X) == Lambda(_x, a*p*(_x/b)**(a*p)*((_x/b)**a + 1)**(-p - 1)/_x) def test_exponential(): rate = Symbol('lambda', positive=True, real=True, bounded=True) X = Exponential(rate) assert E(X) == 1/rate assert variance(X) == 1/rate**2 assert skewness(X) == 2 assert P(X>0) == S(1) assert P(X>1) == exp(-rate) assert P(X>10) == exp(-10*rate) assert where(X<=1).set == Interval(0,1) def test_gamma(): k = Symbol("k", positive=True) theta = Symbol("theta", positive=True) x = Symbol("x") X = Gamma(k, theta, symbol=x) assert density(X) == Lambda(_x, _x**(k - 1)*theta**(-k)*exp(-_x/theta)/gamma(k)) assert cdf(X, meijerg=True) == Lambda(_z, Piecewise((0, _z < 0), (-k*lowergamma(k, 0)/gamma(k + 1) + k*lowergamma(k, _z/theta)/gamma(k + 1), True))) assert variance(X) == (-theta**2*gamma(k + 1)**2/gamma(k)**2 + theta*theta**(-k)*theta**(k + 1)*gamma(k + 2)/gamma(k)) k, theta = symbols('k theta', real=True, bounded=True, positive=True) X = Gamma(k, theta) assert simplify(E(X)) == k*theta # can't get things to simplify on this one so we use subs assert variance(X).subs(k,5) == (k*theta**2).subs(k, 5) # The following is too slow # assert simplify(skewness(X)).subs(k, 5) == (2/sqrt(k)).subs(k, 5) def test_laplace(): mu = Symbol("mu") b = Symbol("b", positive=True) x = Symbol("x") X = Laplace(mu, b, symbol=x) assert density(X) == Lambda(_x, exp(-Abs(_x - mu)/b)/(2*b)) def test_logistic(): mu = Symbol("mu", real=True) s = Symbol("s", positive=True) x = Symbol("x") X = Logistic(mu, s, symbol=x) assert density(X) == Lambda(_x, exp((-_x + mu)/s)/(s*(exp((-_x + mu)/s) + 1)**2)) def test_lognormal(): mean = Symbol('mu', real=True, bounded=True) std = Symbol('sigma', positive=True, real=True, bounded=True) X = LogNormal(mean, std) # The sympy integrator can't do this too well #assert E(X) == exp(mean+std**2/2) #assert variance(X) == (exp(std**2)-1) * exp(2*mean + std**2) # Right now, only density function and sampling works # Test sampling: Only e^mean in sample std of 0 for i in range(3): X = LogNormal(i, 0) assert S(sample(X)) == N(exp(i)) # The sympy integrator can't do this too well #assert E(X) == mu = Symbol("mu", real=True) sigma = Symbol("sigma", positive=True) x = Symbol("x") X = LogNormal(mu, sigma, symbol=x) assert density(X) == (Lambda(_x, sqrt(2)*exp(-(-mu + log(_x))**2 /(2*sigma**2))/(2*_x*sqrt(pi)*sigma))) X = LogNormal(0, 1, symbol=Symbol('x')) # Mean 0, standard deviation 1 assert density(X) == Lambda(_x, sqrt(2)*exp(-log(_x)**2/2)/(2*_x*sqrt(pi))) def test_maxwell(): a = Symbol("a", positive=True) x = Symbol("x") X = Maxwell(a, symbol=x) assert density(X) == (Lambda(_x, sqrt(2)*_x**2*exp(-_x**2/(2*a**2))/ (sqrt(pi)*a**3))) assert E(X) == 2*sqrt(2)*a/sqrt(pi) assert simplify(variance(X)) == a**2*(-8 + 3*pi)/pi def test_nakagami(): mu = Symbol("mu", positive=True) omega = Symbol("omega", positive=True) x = Symbol("x") X = Nakagami(mu, omega, symbol=x) assert density(X) == (Lambda(_x, 2*_x**(2*mu - 1)*mu**mu*omega**(-mu) *exp(-_x**2*mu/omega)/gamma(mu))) assert simplify(E(X, meijerg=True)) == (sqrt(mu)*sqrt(omega) *gamma(mu + S.Half)/gamma(mu + 1)) assert (simplify(variance(X, meijerg=True)) == (omega*(gamma(mu)*gamma(mu + 1) - gamma(mu + S.Half)**2)/(gamma(mu)*gamma(mu + 1)))) def test_pareto(): xm, beta = symbols('xm beta', positive=True, bounded=True) alpha = beta + 5 X = Pareto(xm, alpha) dens = density(X) x = Symbol('x') assert dens(x) == x**(-(alpha+1))*xm**(alpha)*(alpha) # These fail because SymPy can not deduce that 1/xm != 0 # assert simplify(E(X)) == alpha*xm/(alpha-1) # assert simplify(variance(X)) == xm**2*alpha / ((alpha-1)**2*(alpha-2)) def test_pareto_numeric(): xm, beta = 3, 2 alpha = beta + 5 X = Pareto(xm, alpha) assert E(X) == alpha*xm/S(alpha-1) assert variance(X) == xm**2*alpha / S(((alpha-1)**2*(alpha-2))) # Skewness tests too slow. Try shortcutting function? def test_rayleigh(): sigma = Symbol("sigma", positive=True) x = Symbol("x") X = Rayleigh(sigma, symbol=x) assert density(X) == Lambda(_x, _x*exp(-_x**2/(2*sigma**2))/sigma**2) assert E(X) == sqrt(2)*sqrt(pi)*sigma/2 assert variance(X) == -pi*sigma**2/2 + 2*sigma**2 def test_studentt(): nu = Symbol("nu", positive=True) x = Symbol("x") X = StudentT(nu, symbol=x) assert density(X) == (Lambda(_x, (_x**2/nu + 1)**(-nu/2 - S.Half) *gamma(nu/2 + S.Half)/(sqrt(pi)*sqrt(nu)*gamma(nu/2)))) @XFAIL def test_triangular(): a = Symbol("a") b = Symbol("b") c = Symbol("c") x = Symbol("x") X = Triangular(a,b,c, symbol=x) assert Density(X) == Lambda(_x, Piecewise(((2*_x - 2*a)/((-a + b)*(-a + c)), And(a <= _x, _x < c)), (2/(-a + b), _x == c), ((-2*_x + 2*b)/((-a + b)*(b - c)), And(_x <= b, c < _x)), (0, True))) def test_uniform(): l = Symbol('l', real=True, bounded=True) w = Symbol('w', positive=True, bounded=True) X = Uniform(l, l+w) assert simplify(E(X)) == l + w/2 assert simplify(variance(X)) == w**2/12 assert P(X<l) == 0 and P(X>l+w) == 0 # With numbers all is well X = Uniform(3, 5) assert P(X<3) == 0 and P(X>5) == 0 assert P(X<4) == P(X>4) == S.Half @XFAIL def test_uniformsum(): n = Symbol("n", integer=True) x = Symbol("x") _k = Symbol("k") X = UniformSum(n, symbol=x) assert density(X) == (Lambda(_x, Sum((-1)**_k*(-_k + _x)**(n - 1) *binomial(n, _k), (_k, 0, floor(_x)))/factorial(n - 1))) def test_weibull(): a, b = symbols('a b', positive=True) X = Weibull(a, b) assert simplify(E(X)) == simplify(a * gamma(1 + 1/b)) assert simplify(variance(X)) == simplify(a**2 * gamma(1 + 2/b) - E(X)**2) # Skewness tests too slow. Try shortcutting function? def test_weibull_numeric(): # Test for integers and rationals a = 1 bvals = [S.Half, 1, S(3)/2, 5] for b in bvals: X = Weibull(a, b) assert simplify(E(X)) == simplify(a * gamma(1 + 1/S(b))) assert simplify(variance(X)) == simplify( a**2 * gamma(1 + 2/S(b)) - E(X)**2) # Not testing Skew... it's slow with int/frac values > 3/2 def test_wignersemicircle(): R = Symbol("R", positive=True) x = Symbol("x") X = WignerSemicircle(R, symbol=x) assert density(X) == Lambda(_x, 2*sqrt(-_x**2 + R**2)/(pi*R**2)) assert E(X) == 0 def test_prefab_sampling(): N = Normal(0, 1) L = LogNormal(0, 1) E = Exponential(1) P = Pareto(1, 3) W = Weibull(1, 1) U = Uniform(0, 1) B = Beta(2,5) G = Gamma(1,3) variables = [N,L,E,P,W,U,B,G] niter = 10 for var in variables: for i in xrange(niter): assert sample(var) in var.pspace.domain.set def test_input_value_assertions(): a, b = symbols('a b') p, q = symbols('p q', positive=True) raises(ValueError, "Normal(3, 0)") raises(ValueError, "Normal(a, b)") Normal(a, p) # No error raised raises(ValueError, "Exponential(a)") Exponential(p) # No error raised for fn_name in ['Pareto', 'Weibull', 'Beta', 'Gamma']: raises(ValueError, "%s(a, p)" % fn_name) raises(ValueError, "%s(p, a)" % fn_name) eval("%s(p, q)" % fn_name) # No error raised @XFAIL def test_unevaluated(): x = Symbol('x') X = Normal(0,1, symbol=x) assert E(X, evaluate=False) == ( Integral(sqrt(2)*x*exp(-x**2/2)/(2*sqrt(pi)), (x, -oo, oo))) assert E(X+1, evaluate=False) == ( Integral(sqrt(2)*x*exp(-x**2/2)/(2*sqrt(pi)), (x, -oo, oo)) + 1) assert P(X>0, evaluate=False) == ( Integral(sqrt(2)*exp(-x**2/2)/(2*sqrt(pi)), (x, 0, oo))) assert P(X>0, X**2<1, evaluate=False) == ( Integral(sqrt(2)*exp(-x**2/2)/(2*sqrt(pi)* Integral(sqrt(2)*exp(-x**2/2)/(2*sqrt(pi)), (x, -1, 1))), (x, 0, 1)))

bsd-3-clause

denny820909/builder

lib/python2.7/site-packages/buildbot_slave-0.8.8-py2.7.egg/buildslave/commands/transfer.py

4

12091

# This file is part of Buildbot. Buildbot is free software: you can # redistribute it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation, version 2. # # This program 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 General Public License for more # details. # # You should have received a copy of the GNU General Public License along with # this program; if not, write to the Free Software Foundation, Inc., 51 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # Copyright Buildbot Team Members import os, tarfile, tempfile from twisted.python import log from twisted.internet import defer from buildslave.commands.base import Command class TransferCommand(Command): def finished(self, res): if self.debug: log.msg('finished: stderr=%r, rc=%r' % (self.stderr, self.rc)) # don't use self.sendStatus here, since we may no longer be running # if we have been interrupted upd = {'rc': self.rc} if self.stderr: upd['stderr'] = self.stderr self.builder.sendUpdate(upd) return res def interrupt(self): if self.debug: log.msg('interrupted') if self.interrupted: return self.rc = 1 self.interrupted = True # now we wait for the next trip around the loop. It abandon the file # when it sees self.interrupted set. class SlaveFileUploadCommand(TransferCommand): """ Upload a file from slave to build master Arguments: - ['workdir']: base directory to use - ['slavesrc']: name of the slave-side file to read from - ['writer']: RemoteReference to a transfer._FileWriter object - ['maxsize']: max size (in bytes) of file to write - ['blocksize']: max size for each data block - ['keepstamp']: whether to preserve file modified and accessed times """ debug = False def setup(self, args): self.workdir = args['workdir'] self.filename = args['slavesrc'] self.writer = args['writer'] self.remaining = args['maxsize'] self.blocksize = args['blocksize'] self.keepstamp = args.get('keepstamp', False) self.stderr = None self.rc = 0 def start(self): if self.debug: log.msg('SlaveFileUploadCommand started') # Open file self.path = os.path.join(self.builder.basedir, self.workdir, os.path.expanduser(self.filename)) accessed_modified = None try: if self.keepstamp: accessed_modified = (os.path.getatime(self.path), os.path.getmtime(self.path)) self.fp = open(self.path, 'rb') if self.debug: log.msg("Opened '%s' for upload" % self.path) except: self.fp = None self.stderr = "Cannot open file '%s' for upload" % self.path self.rc = 1 if self.debug: log.msg("Cannot open file '%s' for upload" % self.path) self.sendStatus({'header': "sending %s" % self.path}) d = defer.Deferred() self._reactor.callLater(0, self._loop, d) def _close_ok(res): self.fp = None d1 = self.writer.callRemote("close") def _utime_ok(res): return self.writer.callRemote("utime", accessed_modified) if self.keepstamp: d1.addCallback(_utime_ok) return d1 def _close_err(f): self.rc = 1 self.fp = None # call remote's close(), but keep the existing failure d1 = self.writer.callRemote("close") def eb(f2): log.msg("ignoring error from remote close():") log.err(f2) d1.addErrback(eb) d1.addBoth(lambda _ : f) # always return _loop failure return d1 d.addCallbacks(_close_ok, _close_err) d.addBoth(self.finished) return d def _loop(self, fire_when_done): d = defer.maybeDeferred(self._writeBlock) def _done(finished): if finished: fire_when_done.callback(None) else: self._loop(fire_when_done) def _err(why): fire_when_done.errback(why) d.addCallbacks(_done, _err) return None def _writeBlock(self): """Write a block of data to the remote writer""" if self.interrupted or self.fp is None: if self.debug: log.msg('SlaveFileUploadCommand._writeBlock(): end') return True length = self.blocksize if self.remaining is not None and length > self.remaining: length = self.remaining if length <= 0: if self.stderr is None: self.stderr = 'Maximum filesize reached, truncating file \'%s\'' \ % self.path self.rc = 1 data = '' else: data = self.fp.read(length) if self.debug: log.msg('SlaveFileUploadCommand._writeBlock(): '+ 'allowed=%d readlen=%d' % (length, len(data))) if len(data) == 0: log.msg("EOF: callRemote(close)") return True if self.remaining is not None: self.remaining = self.remaining - len(data) assert self.remaining >= 0 d = self.writer.callRemote('write', data) d.addCallback(lambda res: False) return d class SlaveDirectoryUploadCommand(SlaveFileUploadCommand): debug = False def setup(self, args): self.workdir = args['workdir'] self.dirname = args['slavesrc'] self.writer = args['writer'] self.remaining = args['maxsize'] self.blocksize = args['blocksize'] self.compress = args['compress'] self.stderr = None self.rc = 0 def start(self): if self.debug: log.msg('SlaveDirectoryUploadCommand started') self.path = os.path.join(self.builder.basedir, self.workdir, os.path.expanduser(self.dirname)) if self.debug: log.msg("path: %r" % self.path) # Create temporary archive fd, self.tarname = tempfile.mkstemp() fileobj = os.fdopen(fd, 'w') if self.compress == 'bz2': mode='w|bz2' elif self.compress == 'gz': mode='w|gz' else: mode = 'w' archive = tarfile.open(name=self.tarname, mode=mode, fileobj=fileobj) archive.add(self.path, '') archive.close() fileobj.close() # Transfer it self.fp = open(self.tarname, 'rb') self.sendStatus({'header': "sending %s" % self.path}) d = defer.Deferred() self._reactor.callLater(0, self._loop, d) def unpack(res): d1 = self.writer.callRemote("unpack") def unpack_err(f): self.rc = 1 return f d1.addErrback(unpack_err) d1.addCallback(lambda ignored: res) return d1 d.addCallback(unpack) d.addBoth(self.finished) return d def finished(self, res): self.fp.close() os.remove(self.tarname) return TransferCommand.finished(self, res) class SlaveFileDownloadCommand(TransferCommand): """ Download a file from master to slave Arguments: - ['workdir']: base directory to use - ['slavedest']: name of the slave-side file to be created - ['reader']: RemoteReference to a transfer._FileReader object - ['maxsize']: max size (in bytes) of file to write - ['blocksize']: max size for each data block - ['mode']: access mode for the new file """ debug = False def setup(self, args): self.workdir = args['workdir'] self.filename = args['slavedest'] self.reader = args['reader'] self.bytes_remaining = args['maxsize'] self.blocksize = args['blocksize'] self.mode = args['mode'] self.stderr = None self.rc = 0 def start(self): if self.debug: log.msg('SlaveFileDownloadCommand starting') # Open file self.path = os.path.join(self.builder.basedir, self.workdir, os.path.expanduser(self.filename)) dirname = os.path.dirname(self.path) if not os.path.exists(dirname): os.makedirs(dirname) try: self.fp = open(self.path, 'wb') if self.debug: log.msg("Opened '%s' for download" % self.path) if self.mode is not None: # note: there is a brief window during which the new file # will have the buildslave's default (umask) mode before we # set the new one. Don't use this mode= feature to keep files # private: use the buildslave's umask for that instead. (it # is possible to call os.umask() before and after the open() # call, but cleaning up from exceptions properly is more of a # nuisance that way). os.chmod(self.path, self.mode) except IOError: # TODO: this still needs cleanup self.fp = None self.stderr = "Cannot open file '%s' for download" % self.path self.rc = 1 if self.debug: log.msg("Cannot open file '%s' for download" % self.path) d = defer.Deferred() self._reactor.callLater(0, self._loop, d) def _close(res): # close the file, but pass through any errors from _loop d1 = self.reader.callRemote('close') d1.addErrback(log.err, 'while trying to close reader') d1.addCallback(lambda ignored: res) return d1 d.addBoth(_close) d.addBoth(self.finished) return d def _loop(self, fire_when_done): d = defer.maybeDeferred(self._readBlock) def _done(finished): if finished: fire_when_done.callback(None) else: self._loop(fire_when_done) def _err(why): fire_when_done.errback(why) d.addCallbacks(_done, _err) return None def _readBlock(self): """Read a block of data from the remote reader.""" if self.interrupted or self.fp is None: if self.debug: log.msg('SlaveFileDownloadCommand._readBlock(): end') return True length = self.blocksize if self.bytes_remaining is not None and length > self.bytes_remaining: length = self.bytes_remaining if length <= 0: if self.stderr is None: self.stderr = "Maximum filesize reached, truncating file '%s'" \ % self.path self.rc = 1 return True else: d = self.reader.callRemote('read', length) d.addCallback(self._writeData) return d def _writeData(self, data): if self.debug: log.msg('SlaveFileDownloadCommand._readBlock(): readlen=%d' % len(data)) if len(data) == 0: return True if self.bytes_remaining is not None: self.bytes_remaining = self.bytes_remaining - len(data) assert self.bytes_remaining >= 0 self.fp.write(data) return False def finished(self, res): if self.fp is not None: self.fp.close() return TransferCommand.finished(self, res)

mit

palladius/gcloud

packages/gcutil-1.7.1/lib/python_gflags/gflags.py

19

104226

#!/usr/bin/env python # # Copyright (c) 2002, Google 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: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of Google Inc. nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # 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 # OWNER 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. # # --- # Author: Chad Lester # Design and style contributions by: # Amit Patel, Bogdan Cocosel, Daniel Dulitz, Eric Tiedemann, # Eric Veach, Laurence Gonsalves, Matthew Springer # Code reorganized a bit by Craig Silverstein """This module is used to define and parse command line flags. This module defines a *distributed* flag-definition policy: rather than an application having to define all flags in or near main(), each python module defines flags that are useful to it. When one python module imports another, it gains access to the other's flags. (This is implemented by having all modules share a common, global registry object containing all the flag information.) Flags are defined through the use of one of the DEFINE_xxx functions. The specific function used determines how the flag is parsed, checked, and optionally type-converted, when it's seen on the command line. IMPLEMENTATION: DEFINE_* creates a 'Flag' object and registers it with a 'FlagValues' object (typically the global FlagValues FLAGS, defined here). The 'FlagValues' object can scan the command line arguments and pass flag arguments to the corresponding 'Flag' objects for value-checking and type conversion. The converted flag values are available as attributes of the 'FlagValues' object. Code can access the flag through a FlagValues object, for instance gflags.FLAGS.myflag. Typically, the __main__ module passes the command line arguments to gflags.FLAGS for parsing. At bottom, this module calls getopt(), so getopt functionality is supported, including short- and long-style flags, and the use of -- to terminate flags. Methods defined by the flag module will throw 'FlagsError' exceptions. The exception argument will be a human-readable string. FLAG TYPES: This is a list of the DEFINE_*'s that you can do. All flags take a name, default value, help-string, and optional 'short' name (one-letter name). Some flags have other arguments, which are described with the flag. DEFINE_string: takes any input, and interprets it as a string. DEFINE_bool or DEFINE_boolean: typically does not take an argument: say --myflag to set FLAGS.myflag to true, or --nomyflag to set FLAGS.myflag to false. Alternately, you can say --myflag=true or --myflag=t or --myflag=1 or --myflag=false or --myflag=f or --myflag=0 DEFINE_float: takes an input and interprets it as a floating point number. Takes optional args lower_bound and upper_bound; if the number specified on the command line is out of range, it will raise a FlagError. DEFINE_integer: takes an input and interprets it as an integer. Takes optional args lower_bound and upper_bound as for floats. DEFINE_enum: takes a list of strings which represents legal values. If the command-line value is not in this list, raise a flag error. Otherwise, assign to FLAGS.flag as a string. DEFINE_list: Takes a comma-separated list of strings on the commandline. Stores them in a python list object. DEFINE_spaceseplist: Takes a space-separated list of strings on the commandline. Stores them in a python list object. Example: --myspacesepflag "foo bar baz" DEFINE_multistring: The same as DEFINE_string, except the flag can be specified more than once on the commandline. The result is a python list object (list of strings), even if the flag is only on the command line once. DEFINE_multi_int: The same as DEFINE_integer, except the flag can be specified more than once on the commandline. The result is a python list object (list of ints), even if the flag is only on the command line once. SPECIAL FLAGS: There are a few flags that have special meaning: --help prints a list of all the flags in a human-readable fashion --helpshort prints a list of all key flags (see below). --helpxml prints a list of all flags, in XML format. DO NOT parse the output of --help and --helpshort. Instead, parse the output of --helpxml. For more info, see "OUTPUT FOR --helpxml" below. --flagfile=foo read flags from file foo. --undefok=f1,f2 ignore unrecognized option errors for f1,f2. For boolean flags, you should use --undefok=boolflag, and --boolflag and --noboolflag will be accepted. Do not use --undefok=noboolflag. -- as in getopt(), terminates flag-processing FLAGS VALIDATORS: If your program: - requires flag X to be specified - needs flag Y to match a regular expression - or requires any more general constraint to be satisfied then validators are for you! Each validator represents a constraint over one flag, which is enforced starting from the initial parsing of the flags and until the program terminates. Also, lower_bound and upper_bound for numerical flags are enforced using flag validators. Howto: If you want to enforce a constraint over one flag, use gflags.RegisterValidator(flag_name, checker, message='Flag validation failed', flag_values=FLAGS) After flag values are initially parsed, and after any change to the specified flag, method checker(flag_value) will be executed. If constraint is not satisfied, an IllegalFlagValue exception will be raised. See RegisterValidator's docstring for a detailed explanation on how to construct your own checker. EXAMPLE USAGE: FLAGS = gflags.FLAGS gflags.DEFINE_integer('my_version', 0, 'Version number.') gflags.DEFINE_string('filename', None, 'Input file name', short_name='f') gflags.RegisterValidator('my_version', lambda value: value % 2 == 0, message='--my_version must be divisible by 2') gflags.MarkFlagAsRequired('filename') NOTE ON --flagfile: Flags may be loaded from text files in addition to being specified on the commandline. Any flags you don't feel like typing, throw them in a file, one flag per line, for instance: --myflag=myvalue --nomyboolean_flag You then specify your file with the special flag '--flagfile=somefile'. You CAN recursively nest flagfile= tokens OR use multiple files on the command line. Lines beginning with a single hash '#' or a double slash '//' are comments in your flagfile. Any flagfile=<file> will be interpreted as having a relative path from the current working directory rather than from the place the file was included from: myPythonScript.py --flagfile=config/somefile.cfg If somefile.cfg includes further --flagfile= directives, these will be referenced relative to the original CWD, not from the directory the including flagfile was found in! The caveat applies to people who are including a series of nested files in a different dir than they are executing out of. Relative path names are always from CWD, not from the directory of the parent include flagfile. We do now support '~' expanded directory names. Absolute path names ALWAYS work! EXAMPLE USAGE: FLAGS = gflags.FLAGS # Flag names are globally defined! So in general, we need to be # careful to pick names that are unlikely to be used by other libraries. # If there is a conflict, we'll get an error at import time. gflags.DEFINE_string('name', 'Mr. President', 'your name') gflags.DEFINE_integer('age', None, 'your age in years', lower_bound=0) gflags.DEFINE_boolean('debug', False, 'produces debugging output') gflags.DEFINE_enum('gender', 'male', ['male', 'female'], 'your gender') def main(argv): try: argv = FLAGS(argv) # parse flags except gflags.FlagsError, e: print '%s\\nUsage: %s ARGS\\n%s' % (e, sys.argv[0], FLAGS) sys.exit(1) if FLAGS.debug: print 'non-flag arguments:', argv print 'Happy Birthday', FLAGS.name if FLAGS.age is not None: print 'You are a %d year old %s' % (FLAGS.age, FLAGS.gender) if __name__ == '__main__': main(sys.argv) KEY FLAGS: As we already explained, each module gains access to all flags defined by all the other modules it transitively imports. In the case of non-trivial scripts, this means a lot of flags ... For documentation purposes, it is good to identify the flags that are key (i.e., really important) to a module. Clearly, the concept of "key flag" is a subjective one. When trying to determine whether a flag is key to a module or not, assume that you are trying to explain your module to a potential user: which flags would you really like to mention first? We'll describe shortly how to declare which flags are key to a module. For the moment, assume we know the set of key flags for each module. Then, if you use the app.py module, you can use the --helpshort flag to print only the help for the flags that are key to the main module, in a human-readable format. NOTE: If you need to parse the flag help, do NOT use the output of --help / --helpshort. That output is meant for human consumption, and may be changed in the future. Instead, use --helpxml; flags that are key for the main module are marked there with a <key>yes</key> element. The set of key flags for a module M is composed of: 1. Flags defined by module M by calling a DEFINE_* function. 2. Flags that module M explictly declares as key by using the function DECLARE_key_flag(<flag_name>) 3. Key flags of other modules that M specifies by using the function ADOPT_module_key_flags(<other_module>) This is a "bulk" declaration of key flags: each flag that is key for <other_module> becomes key for the current module too. Notice that if you do not use the functions described at points 2 and 3 above, then --helpshort prints information only about the flags defined by the main module of our script. In many cases, this behavior is good enough. But if you move part of the main module code (together with the related flags) into a different module, then it is nice to use DECLARE_key_flag / ADOPT_module_key_flags and make sure --helpshort lists all relevant flags (otherwise, your code refactoring may confuse your users). Note: each of DECLARE_key_flag / ADOPT_module_key_flags has its own pluses and minuses: DECLARE_key_flag is more targeted and may lead a more focused --helpshort documentation. ADOPT_module_key_flags is good for cases when an entire module is considered key to the current script. Also, it does not require updates to client scripts when a new flag is added to the module. EXAMPLE USAGE 2 (WITH KEY FLAGS): Consider an application that contains the following three files (two auxiliary modules and a main module) File libfoo.py: import gflags gflags.DEFINE_integer('num_replicas', 3, 'Number of replicas to start') gflags.DEFINE_boolean('rpc2', True, 'Turn on the usage of RPC2.') ... some code ... File libbar.py: import gflags gflags.DEFINE_string('bar_gfs_path', '/gfs/path', 'Path to the GFS files for libbar.') gflags.DEFINE_string('email_for_bar_errors', 'bar-team@google.com', 'Email address for bug reports about module libbar.') gflags.DEFINE_boolean('bar_risky_hack', False, 'Turn on an experimental and buggy optimization.') ... some code ... File myscript.py: import gflags import libfoo import libbar gflags.DEFINE_integer('num_iterations', 0, 'Number of iterations.') # Declare that all flags that are key for libfoo are # key for this module too. gflags.ADOPT_module_key_flags(libfoo) # Declare that the flag --bar_gfs_path (defined in libbar) is key # for this module. gflags.DECLARE_key_flag('bar_gfs_path') ... some code ... When myscript is invoked with the flag --helpshort, the resulted help message lists information about all the key flags for myscript: --num_iterations, --num_replicas, --rpc2, and --bar_gfs_path. Of course, myscript uses all the flags declared by it (in this case, just --num_replicas) or by any of the modules it transitively imports (e.g., the modules libfoo, libbar). E.g., it can access the value of FLAGS.bar_risky_hack, even if --bar_risky_hack is not declared as a key flag for myscript. OUTPUT FOR --helpxml: The --helpxml flag generates output with the following structure: <?xml version="1.0"?> <AllFlags> <program>PROGRAM_BASENAME</program> <usage>MAIN_MODULE_DOCSTRING</usage> (<flag> [<key>yes</key>] <file>DECLARING_MODULE</file> <name>FLAG_NAME</name> <meaning>FLAG_HELP_MESSAGE</meaning> <default>DEFAULT_FLAG_VALUE</default> <current>CURRENT_FLAG_VALUE</current> <type>FLAG_TYPE</type> [OPTIONAL_ELEMENTS] </flag>)* </AllFlags> Notes: 1. The output is intentionally similar to the output generated by the C++ command-line flag library. The few differences are due to the Python flags that do not have a C++ equivalent (at least not yet), e.g., DEFINE_list. 2. New XML elements may be added in the future. 3. DEFAULT_FLAG_VALUE is in serialized form, i.e., the string you can pass for this flag on the command-line. E.g., for a flag defined using DEFINE_list, this field may be foo,bar, not ['foo', 'bar']. 4. CURRENT_FLAG_VALUE is produced using str(). This means that the string 'false' will be represented in the same way as the boolean False. Using repr() would have removed this ambiguity and simplified parsing, but would have broken the compatibility with the C++ command-line flags. 5. OPTIONAL_ELEMENTS describe elements relevant for certain kinds of flags: lower_bound, upper_bound (for flags that specify bounds), enum_value (for enum flags), list_separator (for flags that consist of a list of values, separated by a special token). 6. We do not provide any example here: please use --helpxml instead. This module requires at least python 2.2.1 to run. """ import cgi import getopt import os import re import string import struct import sys # pylint: disable-msg=C6204 try: import fcntl except ImportError: fcntl = None try: # Importing termios will fail on non-unix platforms. import termios except ImportError: termios = None import gflags_validators # pylint: enable-msg=C6204 # Are we running under pychecker? _RUNNING_PYCHECKER = 'pychecker.python' in sys.modules def _GetCallingModuleObjectAndName(): """Returns the module that's calling into this module. We generally use this function to get the name of the module calling a DEFINE_foo... function. """ # Walk down the stack to find the first globals dict that's not ours. for depth in range(1, sys.getrecursionlimit()): if not sys._getframe(depth).f_globals is globals(): globals_for_frame = sys._getframe(depth).f_globals module, module_name = _GetModuleObjectAndName(globals_for_frame) if module_name is not None: return module, module_name raise AssertionError("No module was found") def _GetCallingModule(): """Returns the name of the module that's calling into this module.""" return _GetCallingModuleObjectAndName()[1] def _GetThisModuleObjectAndName(): """Returns: (module object, module name) for this module.""" return _GetModuleObjectAndName(globals()) # module exceptions: class FlagsError(Exception): """The base class for all flags errors.""" pass class DuplicateFlag(FlagsError): """Raised if there is a flag naming conflict.""" pass class CantOpenFlagFileError(FlagsError): """Raised if flagfile fails to open: doesn't exist, wrong permissions, etc.""" pass class DuplicateFlagCannotPropagateNoneToSwig(DuplicateFlag): """Special case of DuplicateFlag -- SWIG flag value can't be set to None. This can be raised when a duplicate flag is created. Even if allow_override is True, we still abort if the new value is None, because it's currently impossible to pass None default value back to SWIG. See FlagValues.SetDefault for details. """ pass class DuplicateFlagError(DuplicateFlag): """A DuplicateFlag whose message cites the conflicting definitions. A DuplicateFlagError conveys more information than a DuplicateFlag, namely the modules where the conflicting definitions occur. This class was created to avoid breaking external modules which depend on the existing DuplicateFlags interface. """ def __init__(self, flagname, flag_values, other_flag_values=None): """Create a DuplicateFlagError. Args: flagname: Name of the flag being redefined. flag_values: FlagValues object containing the first definition of flagname. other_flag_values: If this argument is not None, it should be the FlagValues object where the second definition of flagname occurs. If it is None, we assume that we're being called when attempting to create the flag a second time, and we use the module calling this one as the source of the second definition. """ self.flagname = flagname first_module = flag_values.FindModuleDefiningFlag( flagname, default='<unknown>') if other_flag_values is None: second_module = _GetCallingModule() else: second_module = other_flag_values.FindModuleDefiningFlag( flagname, default='<unknown>') msg = "The flag '%s' is defined twice. First from %s, Second from %s" % ( self.flagname, first_module, second_module) DuplicateFlag.__init__(self, msg) class IllegalFlagValue(FlagsError): """The flag command line argument is illegal.""" pass class UnrecognizedFlag(FlagsError): """Raised if a flag is unrecognized.""" pass # An UnrecognizedFlagError conveys more information than an UnrecognizedFlag. # Since there are external modules that create DuplicateFlags, the interface to # DuplicateFlag shouldn't change. The flagvalue will be assigned the full value # of the flag and its argument, if any, allowing handling of unrecognized flags # in an exception handler. # If flagvalue is the empty string, then this exception is an due to a # reference to a flag that was not already defined. class UnrecognizedFlagError(UnrecognizedFlag): def __init__(self, flagname, flagvalue=''): self.flagname = flagname self.flagvalue = flagvalue UnrecognizedFlag.__init__( self, "Unknown command line flag '%s'" % flagname) # Global variable used by expvar _exported_flags = {} _help_width = 80 # width of help output def GetHelpWidth(): """Returns: an integer, the width of help lines that is used in TextWrap.""" if (not sys.stdout.isatty()) or (termios is None) or (fcntl is None): return _help_width try: data = fcntl.ioctl(sys.stdout, termios.TIOCGWINSZ, '1234') columns = struct.unpack('hh', data)[1] # Emacs mode returns 0. # Here we assume that any value below 40 is unreasonable if columns >= 40: return columns # Returning an int as default is fine, int(int) just return the int. return int(os.getenv('COLUMNS', _help_width)) except (TypeError, IOError, struct.error): return _help_width def CutCommonSpacePrefix(text): """Removes a common space prefix from the lines of a multiline text. If the first line does not start with a space, it is left as it is and only in the remaining lines a common space prefix is being searched for. That means the first line will stay untouched. This is especially useful to turn doc strings into help texts. This is because some people prefer to have the doc comment start already after the apostrophe and then align the following lines while others have the apostrophes on a separate line. The function also drops trailing empty lines and ignores empty lines following the initial content line while calculating the initial common whitespace. Args: text: text to work on Returns: the resulting text """ text_lines = text.splitlines() # Drop trailing empty lines while text_lines and not text_lines[-1]: text_lines = text_lines[:-1] if text_lines: # We got some content, is the first line starting with a space? if text_lines[0] and text_lines[0][0].isspace(): text_first_line = [] else: text_first_line = [text_lines.pop(0)] # Calculate length of common leading whitespace (only over content lines) common_prefix = os.path.commonprefix([line for line in text_lines if line]) space_prefix_len = len(common_prefix) - len(common_prefix.lstrip()) # If we have a common space prefix, drop it from all lines if space_prefix_len: for index in xrange(len(text_lines)): if text_lines[index]: text_lines[index] = text_lines[index][space_prefix_len:] return '\n'.join(text_first_line + text_lines) return '' def TextWrap(text, length=None, indent='', firstline_indent=None, tabs=' '): """Wraps a given text to a maximum line length and returns it. We turn lines that only contain whitespace into empty lines. We keep new lines and tabs (e.g., we do not treat tabs as spaces). Args: text: text to wrap length: maximum length of a line, includes indentation if this is None then use GetHelpWidth() indent: indent for all but first line firstline_indent: indent for first line; if None, fall back to indent tabs: replacement for tabs Returns: wrapped text Raises: FlagsError: if indent not shorter than length FlagsError: if firstline_indent not shorter than length """ # Get defaults where callee used None if length is None: length = GetHelpWidth() if indent is None: indent = '' if len(indent) >= length: raise FlagsError('Indent must be shorter than length') # In line we will be holding the current line which is to be started # with indent (or firstline_indent if available) and then appended # with words. if firstline_indent is None: firstline_indent = '' line = indent else: line = firstline_indent if len(firstline_indent) >= length: raise FlagsError('First line indent must be shorter than length') # If the callee does not care about tabs we simply convert them to # spaces If callee wanted tabs to be single space then we do that # already here. if not tabs or tabs == ' ': text = text.replace('\t', ' ') else: tabs_are_whitespace = not tabs.strip() line_regex = re.compile('([ ]*)(\t*)([^ \t]+)', re.MULTILINE) # Split the text into lines and the lines with the regex above. The # resulting lines are collected in result[]. For each split we get the # spaces, the tabs and the next non white space (e.g. next word). result = [] for text_line in text.splitlines(): # Store result length so we can find out whether processing the next # line gave any new content old_result_len = len(result) # Process next line with line_regex. For optimization we do an rstrip(). # - process tabs (changes either line or word, see below) # - process word (first try to squeeze on line, then wrap or force wrap) # Spaces found on the line are ignored, they get added while wrapping as # needed. for spaces, current_tabs, word in line_regex.findall(text_line.rstrip()): # If tabs weren't converted to spaces, handle them now if current_tabs: # If the last thing we added was a space anyway then drop # it. But let's not get rid of the indentation. if (((result and line != indent) or (not result and line != firstline_indent)) and line[-1] == ' '): line = line[:-1] # Add the tabs, if that means adding whitespace, just add it at # the line, the rstrip() code while shorten the line down if # necessary if tabs_are_whitespace: line += tabs * len(current_tabs) else: # if not all tab replacement is whitespace we prepend it to the word word = tabs * len(current_tabs) + word # Handle the case where word cannot be squeezed onto current last line if len(line) + len(word) > length and len(indent) + len(word) <= length: result.append(line.rstrip()) line = indent + word word = '' # No space left on line or can we append a space? if len(line) + 1 >= length: result.append(line.rstrip()) line = indent else: line += ' ' # Add word and shorten it up to allowed line length. Restart next # line with indent and repeat, or add a space if we're done (word # finished) This deals with words that cannot fit on one line # (e.g. indent + word longer than allowed line length). while len(line) + len(word) >= length: line += word result.append(line[:length]) word = line[length:] line = indent # Default case, simply append the word and a space if word: line += word + ' ' # End of input line. If we have content we finish the line. If the # current line is just the indent but we had content in during this # original line then we need to add an empty line. if (result and line != indent) or (not result and line != firstline_indent): result.append(line.rstrip()) elif len(result) == old_result_len: result.append('') line = indent return '\n'.join(result) def DocToHelp(doc): """Takes a __doc__ string and reformats it as help.""" # Get rid of starting and ending white space. Using lstrip() or even # strip() could drop more than maximum of first line and right space # of last line. doc = doc.strip() # Get rid of all empty lines whitespace_only_line = re.compile('^[ \t]+$', re.M) doc = whitespace_only_line.sub('', doc) # Cut out common space at line beginnings doc = CutCommonSpacePrefix(doc) # Just like this module's comment, comments tend to be aligned somehow. # In other words they all start with the same amount of white space # 1) keep double new lines # 2) keep ws after new lines if not empty line # 3) all other new lines shall be changed to a space # Solution: Match new lines between non white space and replace with space. doc = re.sub('(?<=\S)\n(?=\S)', ' ', doc, re.M) return doc def _GetModuleObjectAndName(globals_dict): """Returns the module that defines a global environment, and its name. Args: globals_dict: A dictionary that should correspond to an environment providing the values of the globals. Returns: A pair consisting of (1) module object and (2) module name (a string). Returns (None, None) if the module could not be identified. """ # The use of .items() (instead of .iteritems()) is NOT a mistake: if # a parallel thread imports a module while we iterate over # .iteritems() (not nice, but possible), we get a RuntimeError ... # Hence, we use the slightly slower but safer .items(). for name, module in sys.modules.items(): if getattr(module, '__dict__', None) is globals_dict: if name == '__main__': # Pick a more informative name for the main module. name = sys.argv[0] return (module, name) return (None, None) def _GetMainModule(): """Returns: string, name of the module from which execution started.""" # First, try to use the same logic used by _GetCallingModuleObjectAndName(), # i.e., call _GetModuleObjectAndName(). For that we first need to # find the dictionary that the main module uses to store the # globals. # # That's (normally) the same dictionary object that the deepest # (oldest) stack frame is using for globals. deepest_frame = sys._getframe(0) while deepest_frame.f_back is not None: deepest_frame = deepest_frame.f_back globals_for_main_module = deepest_frame.f_globals main_module_name = _GetModuleObjectAndName(globals_for_main_module)[1] # The above strategy fails in some cases (e.g., tools that compute # code coverage by redefining, among other things, the main module). # If so, just use sys.argv[0]. We can probably always do this, but # it's safest to try to use the same logic as _GetCallingModuleObjectAndName() if main_module_name is None: main_module_name = sys.argv[0] return main_module_name class FlagValues: """Registry of 'Flag' objects. A 'FlagValues' can then scan command line arguments, passing flag arguments through to the 'Flag' objects that it owns. It also provides easy access to the flag values. Typically only one 'FlagValues' object is needed by an application: gflags.FLAGS This class is heavily overloaded: 'Flag' objects are registered via __setitem__: FLAGS['longname'] = x # register a new flag The .value attribute of the registered 'Flag' objects can be accessed as attributes of this 'FlagValues' object, through __getattr__. Both the long and short name of the original 'Flag' objects can be used to access its value: FLAGS.longname # parsed flag value FLAGS.x # parsed flag value (short name) Command line arguments are scanned and passed to the registered 'Flag' objects through the __call__ method. Unparsed arguments, including argv[0] (e.g. the program name) are returned. argv = FLAGS(sys.argv) # scan command line arguments The original registered Flag objects can be retrieved through the use of the dictionary-like operator, __getitem__: x = FLAGS['longname'] # access the registered Flag object The str() operator of a 'FlagValues' object provides help for all of the registered 'Flag' objects. """ def __init__(self): # Since everything in this class is so heavily overloaded, the only # way of defining and using fields is to access __dict__ directly. # Dictionary: flag name (string) -> Flag object. self.__dict__['__flags'] = {} # Dictionary: module name (string) -> list of Flag objects that are defined # by that module. self.__dict__['__flags_by_module'] = {} # Dictionary: module id (int) -> list of Flag objects that are defined by # that module. self.__dict__['__flags_by_module_id'] = {} # Dictionary: module name (string) -> list of Flag objects that are # key for that module. self.__dict__['__key_flags_by_module'] = {} # Set if we should use new style gnu_getopt rather than getopt when parsing # the args. Only possible with Python 2.3+ self.UseGnuGetOpt(False) def UseGnuGetOpt(self, use_gnu_getopt=True): """Use GNU-style scanning. Allows mixing of flag and non-flag arguments. See http://docs.python.org/library/getopt.html#getopt.gnu_getopt Args: use_gnu_getopt: wether or not to use GNU style scanning. """ self.__dict__['__use_gnu_getopt'] = use_gnu_getopt def IsGnuGetOpt(self): return self.__dict__['__use_gnu_getopt'] def FlagDict(self): return self.__dict__['__flags'] def FlagsByModuleDict(self): """Returns the dictionary of module_name -> list of defined flags. Returns: A dictionary. Its keys are module names (strings). Its values are lists of Flag objects. """ return self.__dict__['__flags_by_module'] def FlagsByModuleIdDict(self): """Returns the dictionary of module_id -> list of defined flags. Returns: A dictionary. Its keys are module IDs (ints). Its values are lists of Flag objects. """ return self.__dict__['__flags_by_module_id'] def KeyFlagsByModuleDict(self): """Returns the dictionary of module_name -> list of key flags. Returns: A dictionary. Its keys are module names (strings). Its values are lists of Flag objects. """ return self.__dict__['__key_flags_by_module'] def _RegisterFlagByModule(self, module_name, flag): """Records the module that defines a specific flag. We keep track of which flag is defined by which module so that we can later sort the flags by module. Args: module_name: A string, the name of a Python module. flag: A Flag object, a flag that is key to the module. """ flags_by_module = self.FlagsByModuleDict() flags_by_module.setdefault(module_name, []).append(flag) def _RegisterFlagByModuleId(self, module_id, flag): """Records the module that defines a specific flag. Args: module_id: An int, the ID of the Python module. flag: A Flag object, a flag that is key to the module. """ flags_by_module_id = self.FlagsByModuleIdDict() flags_by_module_id.setdefault(module_id, []).append(flag) def _RegisterKeyFlagForModule(self, module_name, flag): """Specifies that a flag is a key flag for a module. Args: module_name: A string, the name of a Python module. flag: A Flag object, a flag that is key to the module. """ key_flags_by_module = self.KeyFlagsByModuleDict() # The list of key flags for the module named module_name. key_flags = key_flags_by_module.setdefault(module_name, []) # Add flag, but avoid duplicates. if flag not in key_flags: key_flags.append(flag) def _GetFlagsDefinedByModule(self, module): """Returns the list of flags defined by a module. Args: module: A module object or a module name (a string). Returns: A new list of Flag objects. Caller may update this list as he wishes: none of those changes will affect the internals of this FlagValue object. """ if not isinstance(module, str): module = module.__name__ return list(self.FlagsByModuleDict().get(module, [])) def _GetKeyFlagsForModule(self, module): """Returns the list of key flags for a module. Args: module: A module object or a module name (a string) Returns: A new list of Flag objects. Caller may update this list as he wishes: none of those changes will affect the internals of this FlagValue object. """ if not isinstance(module, str): module = module.__name__ # Any flag is a key flag for the module that defined it. NOTE: # key_flags is a fresh list: we can update it without affecting the # internals of this FlagValues object. key_flags = self._GetFlagsDefinedByModule(module) # Take into account flags explicitly declared as key for a module. for flag in self.KeyFlagsByModuleDict().get(module, []): if flag not in key_flags: key_flags.append(flag) return key_flags def FindModuleDefiningFlag(self, flagname, default=None): """Return the name of the module defining this flag, or default. Args: flagname: Name of the flag to lookup. default: Value to return if flagname is not defined. Defaults to None. Returns: The name of the module which registered the flag with this name. If no such module exists (i.e. no flag with this name exists), we return default. """ for module, flags in self.FlagsByModuleDict().iteritems(): for flag in flags: if flag.name == flagname or flag.short_name == flagname: return module return default def FindModuleIdDefiningFlag(self, flagname, default=None): """Return the ID of the module defining this flag, or default. Args: flagname: Name of the flag to lookup. default: Value to return if flagname is not defined. Defaults to None. Returns: The ID of the module which registered the flag with this name. If no such module exists (i.e. no flag with this name exists), we return default. """ for module_id, flags in self.FlagsByModuleIdDict().iteritems(): for flag in flags: if flag.name == flagname or flag.short_name == flagname: return module_id return default def AppendFlagValues(self, flag_values): """Appends flags registered in another FlagValues instance. Args: flag_values: registry to copy from """ for flag_name, flag in flag_values.FlagDict().iteritems(): # Each flags with shortname appears here twice (once under its # normal name, and again with its short name). To prevent # problems (DuplicateFlagError) with double flag registration, we # perform a check to make sure that the entry we're looking at is # for its normal name. if flag_name == flag.name: try: self[flag_name] = flag except DuplicateFlagError: raise DuplicateFlagError(flag_name, self, other_flag_values=flag_values) def RemoveFlagValues(self, flag_values): """Remove flags that were previously appended from another FlagValues. Args: flag_values: registry containing flags to remove. """ for flag_name in flag_values.FlagDict(): self.__delattr__(flag_name) def __setitem__(self, name, flag): """Registers a new flag variable.""" fl = self.FlagDict() if not isinstance(flag, Flag): raise IllegalFlagValue(flag) if not isinstance(name, type("")): raise FlagsError("Flag name must be a string") if len(name) == 0: raise FlagsError("Flag name cannot be empty") # If running under pychecker, duplicate keys are likely to be # defined. Disable check for duplicate keys when pycheck'ing. if (name in fl and not flag.allow_override and not fl[name].allow_override and not _RUNNING_PYCHECKER): module, module_name = _GetCallingModuleObjectAndName() if (self.FindModuleDefiningFlag(name) == module_name and id(module) != self.FindModuleIdDefiningFlag(name)): # If the flag has already been defined by a module with the same name, # but a different ID, we can stop here because it indicates that the # module is simply being imported a subsequent time. return raise DuplicateFlagError(name, self) short_name = flag.short_name if short_name is not None: if (short_name in fl and not flag.allow_override and not fl[short_name].allow_override and not _RUNNING_PYCHECKER): raise DuplicateFlagError(short_name, self) fl[short_name] = flag fl[name] = flag global _exported_flags _exported_flags[name] = flag def __getitem__(self, name): """Retrieves the Flag object for the flag --name.""" return self.FlagDict()[name] def __getattr__(self, name): """Retrieves the 'value' attribute of the flag --name.""" fl = self.FlagDict() if name not in fl: raise AttributeError(name) return fl[name].value def __setattr__(self, name, value): """Sets the 'value' attribute of the flag --name.""" fl = self.FlagDict() fl[name].value = value self._AssertValidators(fl[name].validators) return value def _AssertAllValidators(self): all_validators = set() for flag in self.FlagDict().itervalues(): for validator in flag.validators: all_validators.add(validator) self._AssertValidators(all_validators) def _AssertValidators(self, validators): """Assert if all validators in the list are satisfied. Asserts validators in the order they were created. Args: validators: Iterable(gflags_validators.Validator), validators to be verified Raises: AttributeError: if validators work with a non-existing flag. IllegalFlagValue: if validation fails for at least one validator """ for validator in sorted( validators, key=lambda validator: validator.insertion_index): try: validator.Verify(self) except gflags_validators.Error, e: message = validator.PrintFlagsWithValues(self) raise IllegalFlagValue('%s: %s' % (message, str(e))) def _FlagIsRegistered(self, flag_obj): """Checks whether a Flag object is registered under some name. Note: this is non trivial: in addition to its normal name, a flag may have a short name too. In self.FlagDict(), both the normal and the short name are mapped to the same flag object. E.g., calling only "del FLAGS.short_name" is not unregistering the corresponding Flag object (it is still registered under the longer name). Args: flag_obj: A Flag object. Returns: A boolean: True iff flag_obj is registered under some name. """ flag_dict = self.FlagDict() # Check whether flag_obj is registered under its long name. name = flag_obj.name if flag_dict.get(name, None) == flag_obj: return True # Check whether flag_obj is registered under its short name. short_name = flag_obj.short_name if (short_name is not None and flag_dict.get(short_name, None) == flag_obj): return True # The flag cannot be registered under any other name, so we do not # need to do a full search through the values of self.FlagDict(). return False def __delattr__(self, flag_name): """Deletes a previously-defined flag from a flag object. This method makes sure we can delete a flag by using del flag_values_object.<flag_name> E.g., gflags.DEFINE_integer('foo', 1, 'Integer flag.') del gflags.FLAGS.foo Args: flag_name: A string, the name of the flag to be deleted. Raises: AttributeError: When there is no registered flag named flag_name. """ fl = self.FlagDict() if flag_name not in fl: raise AttributeError(flag_name) flag_obj = fl[flag_name] del fl[flag_name] if not self._FlagIsRegistered(flag_obj): # If the Flag object indicated by flag_name is no longer # registered (please see the docstring of _FlagIsRegistered), then # we delete the occurrences of the flag object in all our internal # dictionaries. self.__RemoveFlagFromDictByModule(self.FlagsByModuleDict(), flag_obj) self.__RemoveFlagFromDictByModule(self.FlagsByModuleIdDict(), flag_obj) self.__RemoveFlagFromDictByModule(self.KeyFlagsByModuleDict(), flag_obj) def __RemoveFlagFromDictByModule(self, flags_by_module_dict, flag_obj): """Removes a flag object from a module -> list of flags dictionary. Args: flags_by_module_dict: A dictionary that maps module names to lists of flags. flag_obj: A flag object. """ for unused_module, flags_in_module in flags_by_module_dict.iteritems(): # while (as opposed to if) takes care of multiple occurrences of a # flag in the list for the same module. while flag_obj in flags_in_module: flags_in_module.remove(flag_obj) def SetDefault(self, name, value): """Changes the default value of the named flag object.""" fl = self.FlagDict() if name not in fl: raise AttributeError(name) fl[name].SetDefault(value) self._AssertValidators(fl[name].validators) def __contains__(self, name): """Returns True if name is a value (flag) in the dict.""" return name in self.FlagDict() has_key = __contains__ # a synonym for __contains__() def __iter__(self): return iter(self.FlagDict()) def __call__(self, argv): """Parses flags from argv; stores parsed flags into this FlagValues object. All unparsed arguments are returned. Flags are parsed using the GNU Program Argument Syntax Conventions, using getopt: http://www.gnu.org/software/libc/manual/html_mono/libc.html#Getopt Args: argv: argument list. Can be of any type that may be converted to a list. Returns: The list of arguments not parsed as options, including argv[0] Raises: FlagsError: on any parsing error """ # Support any sequence type that can be converted to a list argv = list(argv) shortopts = "" longopts = [] fl = self.FlagDict() # This pre parses the argv list for --flagfile=<> options. argv = argv[:1] + self.ReadFlagsFromFiles(argv[1:], force_gnu=False) # Correct the argv to support the google style of passing boolean # parameters. Boolean parameters may be passed by using --mybool, # --nomybool, --mybool=(true|false|1|0). getopt does not support # having options that may or may not have a parameter. We replace # instances of the short form --mybool and --nomybool with their # full forms: --mybool=(true|false). original_argv = list(argv) # list() makes a copy shortest_matches = None for name, flag in fl.items(): if not flag.boolean: continue if shortest_matches is None: # Determine the smallest allowable prefix for all flag names shortest_matches = self.ShortestUniquePrefixes(fl) no_name = 'no' + name prefix = shortest_matches[name] no_prefix = shortest_matches[no_name] # Replace all occurrences of this boolean with extended forms for arg_idx in range(1, len(argv)): arg = argv[arg_idx] if arg.find('=') >= 0: continue if arg.startswith('--'+prefix) and ('--'+name).startswith(arg): argv[arg_idx] = ('--%s=true' % name) elif arg.startswith('--'+no_prefix) and ('--'+no_name).startswith(arg): argv[arg_idx] = ('--%s=false' % name) # Loop over all of the flags, building up the lists of short options # and long options that will be passed to getopt. Short options are # specified as a string of letters, each letter followed by a colon # if it takes an argument. Long options are stored in an array of # strings. Each string ends with an '=' if it takes an argument. for name, flag in fl.items(): longopts.append(name + "=") if len(name) == 1: # one-letter option: allow short flag type also shortopts += name if not flag.boolean: shortopts += ":" longopts.append('undefok=') undefok_flags = [] # In case --undefok is specified, loop to pick up unrecognized # options one by one. unrecognized_opts = [] args = argv[1:] while True: try: if self.__dict__['__use_gnu_getopt']: optlist, unparsed_args = getopt.gnu_getopt(args, shortopts, longopts) else: optlist, unparsed_args = getopt.getopt(args, shortopts, longopts) break except getopt.GetoptError, e: if not e.opt or e.opt in fl: # Not an unrecognized option, re-raise the exception as a FlagsError raise FlagsError(e) # Remove offender from args and try again for arg_index in range(len(args)): if ((args[arg_index] == '--' + e.opt) or (args[arg_index] == '-' + e.opt) or (args[arg_index].startswith('--' + e.opt + '='))): unrecognized_opts.append((e.opt, args[arg_index])) args = args[0:arg_index] + args[arg_index+1:] break else: # We should have found the option, so we don't expect to get # here. We could assert, but raising the original exception # might work better. raise FlagsError(e) for name, arg in optlist: if name == '--undefok': flag_names = arg.split(',') undefok_flags.extend(flag_names) # For boolean flags, if --undefok=boolflag is specified, then we should # also accept --noboolflag, in addition to --boolflag. # Since we don't know the type of the undefok'd flag, this will affect # non-boolean flags as well. # NOTE: You shouldn't use --undefok=noboolflag, because then we will # accept --nonoboolflag here. We are choosing not to do the conversion # from noboolflag -> boolflag because of the ambiguity that flag names # can start with 'no'. undefok_flags.extend('no' + name for name in flag_names) continue if name.startswith('--'): # long option name = name[2:] short_option = 0 else: # short option name = name[1:] short_option = 1 if name in fl: flag = fl[name] if flag.boolean and short_option: arg = 1 flag.Parse(arg) # If there were unrecognized options, raise an exception unless # the options were named via --undefok. for opt, value in unrecognized_opts: if opt not in undefok_flags: raise UnrecognizedFlagError(opt, value) if unparsed_args: if self.__dict__['__use_gnu_getopt']: # if using gnu_getopt just return the program name + remainder of argv. ret_val = argv[:1] + unparsed_args else: # unparsed_args becomes the first non-flag detected by getopt to # the end of argv. Because argv may have been modified above, # return original_argv for this region. ret_val = argv[:1] + original_argv[-len(unparsed_args):] else: ret_val = argv[:1] self._AssertAllValidators() return ret_val def Reset(self): """Resets the values to the point before FLAGS(argv) was called.""" for f in self.FlagDict().values(): f.Unparse() def RegisteredFlags(self): """Returns: a list of the names and short names of all registered flags.""" return list(self.FlagDict()) def FlagValuesDict(self): """Returns: a dictionary that maps flag names to flag values.""" flag_values = {} for flag_name in self.RegisteredFlags(): flag = self.FlagDict()[flag_name] flag_values[flag_name] = flag.value return flag_values def __str__(self): """Generates a help string for all known flags.""" return self.GetHelp() def GetHelp(self, prefix=''): """Generates a help string for all known flags.""" helplist = [] flags_by_module = self.FlagsByModuleDict() if flags_by_module: modules = sorted(flags_by_module) # Print the help for the main module first, if possible. main_module = _GetMainModule() if main_module in modules: modules.remove(main_module) modules = [main_module] + modules for module in modules: self.__RenderOurModuleFlags(module, helplist) self.__RenderModuleFlags('gflags', _SPECIAL_FLAGS.FlagDict().values(), helplist) else: # Just print one long list of flags. self.__RenderFlagList( self.FlagDict().values() + _SPECIAL_FLAGS.FlagDict().values(), helplist, prefix) return '\n'.join(helplist) def __RenderModuleFlags(self, module, flags, output_lines, prefix=""): """Generates a help string for a given module.""" if not isinstance(module, str): module = module.__name__ output_lines.append('\n%s%s:' % (prefix, module)) self.__RenderFlagList(flags, output_lines, prefix + " ") def __RenderOurModuleFlags(self, module, output_lines, prefix=""): """Generates a help string for a given module.""" flags = self._GetFlagsDefinedByModule(module) if flags: self.__RenderModuleFlags(module, flags, output_lines, prefix) def __RenderOurModuleKeyFlags(self, module, output_lines, prefix=""): """Generates a help string for the key flags of a given module. Args: module: A module object or a module name (a string). output_lines: A list of strings. The generated help message lines will be appended to this list. prefix: A string that is prepended to each generated help line. """ key_flags = self._GetKeyFlagsForModule(module) if key_flags: self.__RenderModuleFlags(module, key_flags, output_lines, prefix) def ModuleHelp(self, module): """Describe the key flags of a module. Args: module: A module object or a module name (a string). Returns: string describing the key flags of a module. """ helplist = [] self.__RenderOurModuleKeyFlags(module, helplist) return '\n'.join(helplist) def MainModuleHelp(self): """Describe the key flags of the main module. Returns: string describing the key flags of a module. """ return self.ModuleHelp(_GetMainModule()) def __RenderFlagList(self, flaglist, output_lines, prefix=" "): fl = self.FlagDict() special_fl = _SPECIAL_FLAGS.FlagDict() flaglist = [(flag.name, flag) for flag in flaglist] flaglist.sort() flagset = {} for (name, flag) in flaglist: # It's possible this flag got deleted or overridden since being # registered in the per-module flaglist. Check now against the # canonical source of current flag information, the FlagDict. if fl.get(name, None) != flag and special_fl.get(name, None) != flag: # a different flag is using this name now continue # only print help once if flag in flagset: continue flagset[flag] = 1 flaghelp = "" if flag.short_name: flaghelp += "-%s," % flag.short_name if flag.boolean: flaghelp += "--[no]%s" % flag.name + ":" else: flaghelp += "--%s" % flag.name + ":" flaghelp += " " if flag.help: flaghelp += flag.help flaghelp = TextWrap(flaghelp, indent=prefix+" ", firstline_indent=prefix) if flag.default_as_str: flaghelp += "\n" flaghelp += TextWrap("(default: %s)" % flag.default_as_str, indent=prefix+" ") if flag.parser.syntactic_help: flaghelp += "\n" flaghelp += TextWrap("(%s)" % flag.parser.syntactic_help, indent=prefix+" ") output_lines.append(flaghelp) def get(self, name, default): """Returns the value of a flag (if not None) or a default value. Args: name: A string, the name of a flag. default: Default value to use if the flag value is None. """ value = self.__getattr__(name) if value is not None: # Can't do if not value, b/c value might be '0' or "" return value else: return default def ShortestUniquePrefixes(self, fl): """Returns: dictionary; maps flag names to their shortest unique prefix.""" # Sort the list of flag names sorted_flags = [] for name, flag in fl.items(): sorted_flags.append(name) if flag.boolean: sorted_flags.append('no%s' % name) sorted_flags.sort() # For each name in the sorted list, determine the shortest unique # prefix by comparing itself to the next name and to the previous # name (the latter check uses cached info from the previous loop). shortest_matches = {} prev_idx = 0 for flag_idx in range(len(sorted_flags)): curr = sorted_flags[flag_idx] if flag_idx == (len(sorted_flags) - 1): next = None else: next = sorted_flags[flag_idx+1] next_len = len(next) for curr_idx in range(len(curr)): if (next is None or curr_idx >= next_len or curr[curr_idx] != next[curr_idx]): # curr longer than next or no more chars in common shortest_matches[curr] = curr[:max(prev_idx, curr_idx) + 1] prev_idx = curr_idx break else: # curr shorter than (or equal to) next shortest_matches[curr] = curr prev_idx = curr_idx + 1 # next will need at least one more char return shortest_matches def __IsFlagFileDirective(self, flag_string): """Checks whether flag_string contain a --flagfile=<foo> directive.""" if isinstance(flag_string, type("")): if flag_string.startswith('--flagfile='): return 1 elif flag_string == '--flagfile': return 1 elif flag_string.startswith('-flagfile='): return 1 elif flag_string == '-flagfile': return 1 else: return 0 return 0 def ExtractFilename(self, flagfile_str): """Returns filename from a flagfile_str of form -[-]flagfile=filename. The cases of --flagfile foo and -flagfile foo shouldn't be hitting this function, as they are dealt with in the level above this function. """ if flagfile_str.startswith('--flagfile='): return os.path.expanduser((flagfile_str[(len('--flagfile=')):]).strip()) elif flagfile_str.startswith('-flagfile='): return os.path.expanduser((flagfile_str[(len('-flagfile=')):]).strip()) else: raise FlagsError('Hit illegal --flagfile type: %s' % flagfile_str) def __GetFlagFileLines(self, filename, parsed_file_list): """Returns the useful (!=comments, etc) lines from a file with flags. Args: filename: A string, the name of the flag file. parsed_file_list: A list of the names of the files we have already read. MUTATED BY THIS FUNCTION. Returns: List of strings. See the note below. NOTE(user): This function checks for a nested --flagfile=<foo> tag and handles the lower file recursively. It returns a list of all the lines that _could_ contain command flags. This is EVERYTHING except whitespace lines and comments (lines starting with '#' or '//'). """ line_list = [] # All line from flagfile. flag_line_list = [] # Subset of lines w/o comments, blanks, flagfile= tags. try: file_obj = open(filename, 'r') except IOError, e_msg: raise CantOpenFlagFileError('ERROR:: Unable to open flagfile: %s' % e_msg) line_list = file_obj.readlines() file_obj.close() parsed_file_list.append(filename) # This is where we check each line in the file we just read. for line in line_list: if line.isspace(): pass # Checks for comment (a line that starts with '#'). elif line.startswith('#') or line.startswith('//'): pass # Checks for a nested "--flagfile=<bar>" flag in the current file. # If we find one, recursively parse down into that file. elif self.__IsFlagFileDirective(line): sub_filename = self.ExtractFilename(line) # We do a little safety check for reparsing a file we've already done. if not sub_filename in parsed_file_list: included_flags = self.__GetFlagFileLines(sub_filename, parsed_file_list) flag_line_list.extend(included_flags) else: # Case of hitting a circularly included file. sys.stderr.write('Warning: Hit circular flagfile dependency: %s\n' % (sub_filename,)) else: # Any line that's not a comment or a nested flagfile should get # copied into 2nd position. This leaves earlier arguments # further back in the list, thus giving them higher priority. flag_line_list.append(line.strip()) return flag_line_list def ReadFlagsFromFiles(self, argv, force_gnu=True): """Processes command line args, but also allow args to be read from file. Args: argv: A list of strings, usually sys.argv[1:], which may contain one or more flagfile directives of the form --flagfile="./filename". Note that the name of the program (sys.argv[0]) should be omitted. force_gnu: If False, --flagfile parsing obeys normal flag semantics. If True, --flagfile parsing instead follows gnu_getopt semantics. *** WARNING *** force_gnu=False may become the future default! Returns: A new list which has the original list combined with what we read from any flagfile(s). References: Global gflags.FLAG class instance. This function should be called before the normal FLAGS(argv) call. This function scans the input list for a flag that looks like: --flagfile=<somefile>. Then it opens <somefile>, reads all valid key and value pairs and inserts them into the input list between the first item of the list and any subsequent items in the list. Note that your application's flags are still defined the usual way using gflags DEFINE_flag() type functions. Notes (assuming we're getting a commandline of some sort as our input): --> Flags from the command line argv _should_ always take precedence! --> A further "--flagfile=<otherfile.cfg>" CAN be nested in a flagfile. It will be processed after the parent flag file is done. --> For duplicate flags, first one we hit should "win". --> In a flagfile, a line beginning with # or // is a comment. --> Entirely blank lines _should_ be ignored. """ parsed_file_list = [] rest_of_args = argv new_argv = [] while rest_of_args: current_arg = rest_of_args[0] rest_of_args = rest_of_args[1:] if self.__IsFlagFileDirective(current_arg): # This handles the case of -(-)flagfile foo. In this case the # next arg really is part of this one. if current_arg == '--flagfile' or current_arg == '-flagfile': if not rest_of_args: raise IllegalFlagValue('--flagfile with no argument') flag_filename = os.path.expanduser(rest_of_args[0]) rest_of_args = rest_of_args[1:] else: # This handles the case of (-)-flagfile=foo. flag_filename = self.ExtractFilename(current_arg) new_argv.extend( self.__GetFlagFileLines(flag_filename, parsed_file_list)) else: new_argv.append(current_arg) # Stop parsing after '--', like getopt and gnu_getopt. if current_arg == '--': break # Stop parsing after a non-flag, like getopt. if not current_arg.startswith('-'): if not force_gnu and not self.__dict__['__use_gnu_getopt']: break if rest_of_args: new_argv.extend(rest_of_args) return new_argv def FlagsIntoString(self): """Returns a string with the flags assignments from this FlagValues object. This function ignores flags whose value is None. Each flag assignment is separated by a newline. NOTE: MUST mirror the behavior of the C++ CommandlineFlagsIntoString from http://code.google.com/p/google-gflags """ s = '' for flag in self.FlagDict().values(): if flag.value is not None: s += flag.Serialize() + '\n' return s def AppendFlagsIntoFile(self, filename): """Appends all flags assignments from this FlagInfo object to a file. Output will be in the format of a flagfile. NOTE: MUST mirror the behavior of the C++ AppendFlagsIntoFile from http://code.google.com/p/google-gflags """ out_file = open(filename, 'a') out_file.write(self.FlagsIntoString()) out_file.close() def WriteHelpInXMLFormat(self, outfile=None): """Outputs flag documentation in XML format. NOTE: We use element names that are consistent with those used by the C++ command-line flag library, from http://code.google.com/p/google-gflags We also use a few new elements (e.g., <key>), but we do not interfere / overlap with existing XML elements used by the C++ library. Please maintain this consistency. Args: outfile: File object we write to. Default None means sys.stdout. """ outfile = outfile or sys.stdout outfile.write('<?xml version=\"1.0\"?>\n') outfile.write('<AllFlags>\n') indent = ' ' _WriteSimpleXMLElement(outfile, 'program', os.path.basename(sys.argv[0]), indent) usage_doc = sys.modules['__main__'].__doc__ if not usage_doc: usage_doc = '\nUSAGE: %s [flags]\n' % sys.argv[0] else: usage_doc = usage_doc.replace('%s', sys.argv[0]) _WriteSimpleXMLElement(outfile, 'usage', usage_doc, indent) # Get list of key flags for the main module. key_flags = self._GetKeyFlagsForModule(_GetMainModule()) # Sort flags by declaring module name and next by flag name. flags_by_module = self.FlagsByModuleDict() all_module_names = list(flags_by_module.keys()) all_module_names.sort() for module_name in all_module_names: flag_list = [(f.name, f) for f in flags_by_module[module_name]] flag_list.sort() for unused_flag_name, flag in flag_list: is_key = flag in key_flags flag.WriteInfoInXMLFormat(outfile, module_name, is_key=is_key, indent=indent) outfile.write('</AllFlags>\n') outfile.flush() def AddValidator(self, validator): """Register new flags validator to be checked. Args: validator: gflags_validators.Validator Raises: AttributeError: if validators work with a non-existing flag. """ for flag_name in validator.GetFlagsNames(): flag = self.FlagDict()[flag_name] flag.validators.append(validator) # end of FlagValues definition # The global FlagValues instance FLAGS = FlagValues() def _StrOrUnicode(value): """Converts value to a python string or, if necessary, unicode-string.""" try: return str(value) except UnicodeEncodeError: return unicode(value) def _MakeXMLSafe(s): """Escapes <, >, and & from s, and removes XML 1.0-illegal chars.""" s = cgi.escape(s) # Escape <, >, and & # Remove characters that cannot appear in an XML 1.0 document # (http://www.w3.org/TR/REC-xml/#charsets). # # NOTE: if there are problems with current solution, one may move to # XML 1.1, which allows such chars, if they're entity-escaped (&#xHH;). s = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f]', '', s) # Convert non-ascii characters to entities. Note: requires python >=2.3 s = s.encode('ascii', 'xmlcharrefreplace') # u'\xce\x88' -> 'u&#904;' return s def _WriteSimpleXMLElement(outfile, name, value, indent): """Writes a simple XML element. Args: outfile: File object we write the XML element to. name: A string, the name of XML element. value: A Python object, whose string representation will be used as the value of the XML element. indent: A string, prepended to each line of generated output. """ value_str = _StrOrUnicode(value) if isinstance(value, bool): # Display boolean values as the C++ flag library does: no caps. value_str = value_str.lower() safe_value_str = _MakeXMLSafe(value_str) outfile.write('%s<%s>%s</%s>\n' % (indent, name, safe_value_str, name)) class Flag: """Information about a command-line flag. 'Flag' objects define the following fields: .name - the name for this flag .default - the default value for this flag .default_as_str - default value as repr'd string, e.g., "'true'" (or None) .value - the most recent parsed value of this flag; set by Parse() .help - a help string or None if no help is available .short_name - the single letter alias for this flag (or None) .boolean - if 'true', this flag does not accept arguments .present - true if this flag was parsed from command line flags. .parser - an ArgumentParser object .serializer - an ArgumentSerializer object .allow_override - the flag may be redefined without raising an error The only public method of a 'Flag' object is Parse(), but it is typically only called by a 'FlagValues' object. The Parse() method is a thin wrapper around the 'ArgumentParser' Parse() method. The parsed value is saved in .value, and the .present attribute is updated. If this flag was already present, a FlagsError is raised. Parse() is also called during __init__ to parse the default value and initialize the .value attribute. This enables other python modules to safely use flags even if the __main__ module neglects to parse the command line arguments. The .present attribute is cleared after __init__ parsing. If the default value is set to None, then the __init__ parsing step is skipped and the .value attribute is initialized to None. Note: The default value is also presented to the user in the help string, so it is important that it be a legal value for this flag. """ def __init__(self, parser, serializer, name, default, help_string, short_name=None, boolean=0, allow_override=0): self.name = name if not help_string: help_string = '(no help available)' self.help = help_string self.short_name = short_name self.boolean = boolean self.present = 0 self.parser = parser self.serializer = serializer self.allow_override = allow_override self.value = None self.validators = [] self.SetDefault(default) def __hash__(self): return hash(id(self)) def __eq__(self, other): return self is other def __lt__(self, other): if isinstance(other, Flag): return id(self) < id(other) return NotImplemented def __GetParsedValueAsString(self, value): if value is None: return None if self.serializer: return repr(self.serializer.Serialize(value)) if self.boolean: if value: return repr('true') else: return repr('false') return repr(_StrOrUnicode(value)) def Parse(self, argument): try: self.value = self.parser.Parse(argument) except ValueError, e: # recast ValueError as IllegalFlagValue raise IllegalFlagValue("flag --%s=%s: %s" % (self.name, argument, e)) self.present += 1 def Unparse(self): if self.default is None: self.value = None else: self.Parse(self.default) self.present = 0 def Serialize(self): if self.value is None: return '' if self.boolean: if self.value: return "--%s" % self.name else: return "--no%s" % self.name else: if not self.serializer: raise FlagsError("Serializer not present for flag %s" % self.name) return "--%s=%s" % (self.name, self.serializer.Serialize(self.value)) def SetDefault(self, value): """Changes the default value (and current value too) for this Flag.""" # We can't allow a None override because it may end up not being # passed to C++ code when we're overriding C++ flags. So we # cowardly bail out until someone fixes the semantics of trying to # pass None to a C++ flag. See swig_flags.Init() for details on # this behavior. # TODO(user): Users can directly call this method, bypassing all flags # validators (we don't have FlagValues here, so we can not check # validators). # The simplest solution I see is to make this method private. # Another approach would be to store reference to the corresponding # FlagValues with each flag, but this seems to be an overkill. if value is None and self.allow_override: raise DuplicateFlagCannotPropagateNoneToSwig(self.name) self.default = value self.Unparse() self.default_as_str = self.__GetParsedValueAsString(self.value) def Type(self): """Returns: a string that describes the type of this Flag.""" # NOTE: we use strings, and not the types.*Type constants because # our flags can have more exotic types, e.g., 'comma separated list # of strings', 'whitespace separated list of strings', etc. return self.parser.Type() def WriteInfoInXMLFormat(self, outfile, module_name, is_key=False, indent=''): """Writes common info about this flag, in XML format. This is information that is relevant to all flags (e.g., name, meaning, etc.). If you defined a flag that has some other pieces of info, then please override _WriteCustomInfoInXMLFormat. Please do NOT override this method. Args: outfile: File object we write to. module_name: A string, the name of the module that defines this flag. is_key: A boolean, True iff this flag is key for main module. indent: A string that is prepended to each generated line. """ outfile.write(indent + '<flag>\n') inner_indent = indent + ' ' if is_key: _WriteSimpleXMLElement(outfile, 'key', 'yes', inner_indent) _WriteSimpleXMLElement(outfile, 'file', module_name, inner_indent) # Print flag features that are relevant for all flags. _WriteSimpleXMLElement(outfile, 'name', self.name, inner_indent) if self.short_name: _WriteSimpleXMLElement(outfile, 'short_name', self.short_name, inner_indent) if self.help: _WriteSimpleXMLElement(outfile, 'meaning', self.help, inner_indent) # The default flag value can either be represented as a string like on the # command line, or as a Python object. We serialize this value in the # latter case in order to remain consistent. if self.serializer and not isinstance(self.default, str): default_serialized = self.serializer.Serialize(self.default) else: default_serialized = self.default _WriteSimpleXMLElement(outfile, 'default', default_serialized, inner_indent) _WriteSimpleXMLElement(outfile, 'current', self.value, inner_indent) _WriteSimpleXMLElement(outfile, 'type', self.Type(), inner_indent) # Print extra flag features this flag may have. self._WriteCustomInfoInXMLFormat(outfile, inner_indent) outfile.write(indent + '</flag>\n') def _WriteCustomInfoInXMLFormat(self, outfile, indent): """Writes extra info about this flag, in XML format. "Extra" means "not already printed by WriteInfoInXMLFormat above." Args: outfile: File object we write to. indent: A string that is prepended to each generated line. """ # Usually, the parser knows the extra details about the flag, so # we just forward the call to it. self.parser.WriteCustomInfoInXMLFormat(outfile, indent) # End of Flag definition class _ArgumentParserCache(type): """Metaclass used to cache and share argument parsers among flags.""" _instances = {} def __call__(mcs, *args, **kwargs): """Returns an instance of the argument parser cls. This method overrides behavior of the __new__ methods in all subclasses of ArgumentParser (inclusive). If an instance for mcs with the same set of arguments exists, this instance is returned, otherwise a new instance is created. If any keyword arguments are defined, or the values in args are not hashable, this method always returns a new instance of cls. Args: args: Positional initializer arguments. kwargs: Initializer keyword arguments. Returns: An instance of cls, shared or new. """ if kwargs: return type.__call__(mcs, *args, **kwargs) else: instances = mcs._instances key = (mcs,) + tuple(args) try: return instances[key] except KeyError: # No cache entry for key exists, create a new one. return instances.setdefault(key, type.__call__(mcs, *args)) except TypeError: # An object in args cannot be hashed, always return # a new instance. return type.__call__(mcs, *args) class ArgumentParser(object): """Base class used to parse and convert arguments. The Parse() method checks to make sure that the string argument is a legal value and convert it to a native type. If the value cannot be converted, it should throw a 'ValueError' exception with a human readable explanation of why the value is illegal. Subclasses should also define a syntactic_help string which may be presented to the user to describe the form of the legal values. Argument parser classes must be stateless, since instances are cached and shared between flags. Initializer arguments are allowed, but all member variables must be derived from initializer arguments only. """ __metaclass__ = _ArgumentParserCache syntactic_help = "" def Parse(self, argument): """Default implementation: always returns its argument unmodified.""" return argument def Type(self): return 'string' def WriteCustomInfoInXMLFormat(self, outfile, indent): pass class ArgumentSerializer: """Base class for generating string representations of a flag value.""" def Serialize(self, value): return _StrOrUnicode(value) class ListSerializer(ArgumentSerializer): def __init__(self, list_sep): self.list_sep = list_sep def Serialize(self, value): return self.list_sep.join([_StrOrUnicode(x) for x in value]) # Flags validators def RegisterValidator(flag_name, checker, message='Flag validation failed', flag_values=FLAGS): """Adds a constraint, which will be enforced during program execution. The constraint is validated when flags are initially parsed, and after each change of the corresponding flag's value. Args: flag_name: string, name of the flag to be checked. checker: method to validate the flag. input - value of the corresponding flag (string, boolean, etc. This value will be passed to checker by the library). See file's docstring for examples. output - Boolean. Must return True if validator constraint is satisfied. If constraint is not satisfied, it should either return False or raise gflags_validators.Error(desired_error_message). message: error text to be shown to the user if checker returns False. If checker raises gflags_validators.Error, message from the raised Error will be shown. flag_values: FlagValues Raises: AttributeError: if flag_name is not registered as a valid flag name. """ flag_values.AddValidator(gflags_validators.SimpleValidator(flag_name, checker, message)) def MarkFlagAsRequired(flag_name, flag_values=FLAGS): """Ensure that flag is not None during program execution. Registers a flag validator, which will follow usual validator rules. Args: flag_name: string, name of the flag flag_values: FlagValues Raises: AttributeError: if flag_name is not registered as a valid flag name. """ RegisterValidator(flag_name, lambda value: value is not None, message='Flag --%s must be specified.' % flag_name, flag_values=flag_values) def _RegisterBoundsValidatorIfNeeded(parser, name, flag_values): """Enforce lower and upper bounds for numeric flags. Args: parser: NumericParser (either FloatParser or IntegerParser). Provides lower and upper bounds, and help text to display. name: string, name of the flag flag_values: FlagValues """ if parser.lower_bound is not None or parser.upper_bound is not None: def Checker(value): if value is not None and parser.IsOutsideBounds(value): message = '%s is not %s' % (value, parser.syntactic_help) raise gflags_validators.Error(message) return True RegisterValidator(name, Checker, flag_values=flag_values) # The DEFINE functions are explained in mode details in the module doc string. def DEFINE(parser, name, default, help, flag_values=FLAGS, serializer=None, **args): """Registers a generic Flag object. NOTE: in the docstrings of all DEFINE* functions, "registers" is short for "creates a new flag and registers it". Auxiliary function: clients should use the specialized DEFINE_<type> function instead. Args: parser: ArgumentParser that is used to parse the flag arguments. name: A string, the flag name. default: The default value of the flag. help: A help string. flag_values: FlagValues object the flag will be registered with. serializer: ArgumentSerializer that serializes the flag value. args: Dictionary with extra keyword args that are passes to the Flag __init__. """ DEFINE_flag(Flag(parser, serializer, name, default, help, **args), flag_values) def DEFINE_flag(flag, flag_values=FLAGS): """Registers a 'Flag' object with a 'FlagValues' object. By default, the global FLAGS 'FlagValue' object is used. Typical users will use one of the more specialized DEFINE_xxx functions, such as DEFINE_string or DEFINE_integer. But developers who need to create Flag objects themselves should use this function to register their flags. """ # copying the reference to flag_values prevents pychecker warnings fv = flag_values fv[flag.name] = flag # Tell flag_values who's defining the flag. if isinstance(flag_values, FlagValues): # Regarding the above isinstance test: some users pass funny # values of flag_values (e.g., {}) in order to avoid the flag # registration (in the past, there used to be a flag_values == # FLAGS test here) and redefine flags with the same name (e.g., # debug). To avoid breaking their code, we perform the # registration only if flag_values is a real FlagValues object. module, module_name = _GetCallingModuleObjectAndName() flag_values._RegisterFlagByModule(module_name, flag) flag_values._RegisterFlagByModuleId(id(module), flag) def _InternalDeclareKeyFlags(flag_names, flag_values=FLAGS, key_flag_values=None): """Declares a flag as key for the calling module. Internal function. User code should call DECLARE_key_flag or ADOPT_module_key_flags instead. Args: flag_names: A list of strings that are names of already-registered Flag objects. flag_values: A FlagValues object that the flags listed in flag_names have registered with (the value of the flag_values argument from the DEFINE_* calls that defined those flags). This should almost never need to be overridden. key_flag_values: A FlagValues object that (among possibly many other things) keeps track of the key flags for each module. Default None means "same as flag_values". This should almost never need to be overridden. Raises: UnrecognizedFlagError: when we refer to a flag that was not defined yet. """ key_flag_values = key_flag_values or flag_values module = _GetCallingModule() for flag_name in flag_names: if flag_name not in flag_values: raise UnrecognizedFlagError(flag_name) flag = flag_values.FlagDict()[flag_name] key_flag_values._RegisterKeyFlagForModule(module, flag) def DECLARE_key_flag(flag_name, flag_values=FLAGS): """Declares one flag as key to the current module. Key flags are flags that are deemed really important for a module. They are important when listing help messages; e.g., if the --helpshort command-line flag is used, then only the key flags of the main module are listed (instead of all flags, as in the case of --help). Sample usage: gflags.DECLARED_key_flag('flag_1') Args: flag_name: A string, the name of an already declared flag. (Redeclaring flags as key, including flags implicitly key because they were declared in this module, is a no-op.) flag_values: A FlagValues object. This should almost never need to be overridden. """ if flag_name in _SPECIAL_FLAGS: # Take care of the special flags, e.g., --flagfile, --undefok. # These flags are defined in _SPECIAL_FLAGS, and are treated # specially during flag parsing, taking precedence over the # user-defined flags. _InternalDeclareKeyFlags([flag_name], flag_values=_SPECIAL_FLAGS, key_flag_values=flag_values) return _InternalDeclareKeyFlags([flag_name], flag_values=flag_values) def ADOPT_module_key_flags(module, flag_values=FLAGS): """Declares that all flags key to a module are key to the current module. Args: module: A module object. flag_values: A FlagValues object. This should almost never need to be overridden. Raises: FlagsError: When given an argument that is a module name (a string), instead of a module object. """ # NOTE(user): an even better test would be if not # isinstance(module, types.ModuleType) but I didn't want to import # types for such a tiny use. if isinstance(module, str): raise FlagsError('Received module name %s; expected a module object.' % module) _InternalDeclareKeyFlags( [f.name for f in flag_values._GetKeyFlagsForModule(module.__name__)], flag_values=flag_values) # If module is this flag module, take _SPECIAL_FLAGS into account. if module == _GetThisModuleObjectAndName()[0]: _InternalDeclareKeyFlags( # As we associate flags with _GetCallingModuleObjectAndName(), the # special flags defined in this module are incorrectly registered with # a different module. So, we can't use _GetKeyFlagsForModule. # Instead, we take all flags from _SPECIAL_FLAGS (a private # FlagValues, where no other module should register flags). [f.name for f in _SPECIAL_FLAGS.FlagDict().values()], flag_values=_SPECIAL_FLAGS, key_flag_values=flag_values) # # STRING FLAGS # def DEFINE_string(name, default, help, flag_values=FLAGS, **args): """Registers a flag whose value can be any string.""" parser = ArgumentParser() serializer = ArgumentSerializer() DEFINE(parser, name, default, help, flag_values, serializer, **args) # # BOOLEAN FLAGS # class BooleanParser(ArgumentParser): """Parser of boolean values.""" def Convert(self, argument): """Converts the argument to a boolean; raise ValueError on errors.""" if type(argument) == str: if argument.lower() in ['true', 't', '1']: return True elif argument.lower() in ['false', 'f', '0']: return False bool_argument = bool(argument) if argument == bool_argument: # The argument is a valid boolean (True, False, 0, or 1), and not just # something that always converts to bool (list, string, int, etc.). return bool_argument raise ValueError('Non-boolean argument to boolean flag', argument) def Parse(self, argument): val = self.Convert(argument) return val def Type(self): return 'bool' class BooleanFlag(Flag): """Basic boolean flag. Boolean flags do not take any arguments, and their value is either True (1) or False (0). The false value is specified on the command line by prepending the word 'no' to either the long or the short flag name. For example, if a Boolean flag was created whose long name was 'update' and whose short name was 'x', then this flag could be explicitly unset through either --noupdate or --nox. """ def __init__(self, name, default, help, short_name=None, **args): p = BooleanParser() Flag.__init__(self, p, None, name, default, help, short_name, 1, **args) if not self.help: self.help = "a boolean value" def DEFINE_boolean(name, default, help, flag_values=FLAGS, **args): """Registers a boolean flag. Such a boolean flag does not take an argument. If a user wants to specify a false value explicitly, the long option beginning with 'no' must be used: i.e. --noflag This flag will have a value of None, True or False. None is possible if default=None and the user does not specify the flag on the command line. """ DEFINE_flag(BooleanFlag(name, default, help, **args), flag_values) # Match C++ API to unconfuse C++ people. DEFINE_bool = DEFINE_boolean class HelpFlag(BooleanFlag): """ HelpFlag is a special boolean flag that prints usage information and raises a SystemExit exception if it is ever found in the command line arguments. Note this is called with allow_override=1, so other apps can define their own --help flag, replacing this one, if they want. """ def __init__(self): BooleanFlag.__init__(self, "help", 0, "show this help", short_name="?", allow_override=1) def Parse(self, arg): if arg: doc = sys.modules["__main__"].__doc__ flags = str(FLAGS) print doc or ("\nUSAGE: %s [flags]\n" % sys.argv[0]) if flags: print "flags:" print flags sys.exit(1) class HelpXMLFlag(BooleanFlag): """Similar to HelpFlag, but generates output in XML format.""" def __init__(self): BooleanFlag.__init__(self, 'helpxml', False, 'like --help, but generates XML output', allow_override=1) def Parse(self, arg): if arg: FLAGS.WriteHelpInXMLFormat(sys.stdout) sys.exit(1) class HelpshortFlag(BooleanFlag): """ HelpshortFlag is a special boolean flag that prints usage information for the "main" module, and rasies a SystemExit exception if it is ever found in the command line arguments. Note this is called with allow_override=1, so other apps can define their own --helpshort flag, replacing this one, if they want. """ def __init__(self): BooleanFlag.__init__(self, "helpshort", 0, "show usage only for this module", allow_override=1) def Parse(self, arg): if arg: doc = sys.modules["__main__"].__doc__ flags = FLAGS.MainModuleHelp() print doc or ("\nUSAGE: %s [flags]\n" % sys.argv[0]) if flags: print "flags:" print flags sys.exit(1) # # Numeric parser - base class for Integer and Float parsers # class NumericParser(ArgumentParser): """Parser of numeric values. Parsed value may be bounded to a given upper and lower bound. """ def IsOutsideBounds(self, val): return ((self.lower_bound is not None and val < self.lower_bound) or (self.upper_bound is not None and val > self.upper_bound)) def Parse(self, argument): val = self.Convert(argument) if self.IsOutsideBounds(val): raise ValueError("%s is not %s" % (val, self.syntactic_help)) return val def WriteCustomInfoInXMLFormat(self, outfile, indent): if self.lower_bound is not None: _WriteSimpleXMLElement(outfile, 'lower_bound', self.lower_bound, indent) if self.upper_bound is not None: _WriteSimpleXMLElement(outfile, 'upper_bound', self.upper_bound, indent) def Convert(self, argument): """Default implementation: always returns its argument unmodified.""" return argument # End of Numeric Parser # # FLOAT FLAGS # class FloatParser(NumericParser): """Parser of floating point values. Parsed value may be bounded to a given upper and lower bound. """ number_article = "a" number_name = "number" syntactic_help = " ".join((number_article, number_name)) def __init__(self, lower_bound=None, upper_bound=None): super(FloatParser, self).__init__() self.lower_bound = lower_bound self.upper_bound = upper_bound sh = self.syntactic_help if lower_bound is not None and upper_bound is not None: sh = ("%s in the range [%s, %s]" % (sh, lower_bound, upper_bound)) elif lower_bound == 0: sh = "a non-negative %s" % self.number_name elif upper_bound == 0: sh = "a non-positive %s" % self.number_name elif upper_bound is not None: sh = "%s <= %s" % (self.number_name, upper_bound) elif lower_bound is not None: sh = "%s >= %s" % (self.number_name, lower_bound) self.syntactic_help = sh def Convert(self, argument): """Converts argument to a float; raises ValueError on errors.""" return float(argument) def Type(self): return 'float' # End of FloatParser def DEFINE_float(name, default, help, lower_bound=None, upper_bound=None, flag_values=FLAGS, **args): """Registers a flag whose value must be a float. If lower_bound or upper_bound are set, then this flag must be within the given range. """ parser = FloatParser(lower_bound, upper_bound) serializer = ArgumentSerializer() DEFINE(parser, name, default, help, flag_values, serializer, **args) _RegisterBoundsValidatorIfNeeded(parser, name, flag_values=flag_values) # # INTEGER FLAGS # class IntegerParser(NumericParser): """Parser of an integer value. Parsed value may be bounded to a given upper and lower bound. """ number_article = "an" number_name = "integer" syntactic_help = " ".join((number_article, number_name)) def __init__(self, lower_bound=None, upper_bound=None): super(IntegerParser, self).__init__() self.lower_bound = lower_bound self.upper_bound = upper_bound sh = self.syntactic_help if lower_bound is not None and upper_bound is not None: sh = ("%s in the range [%s, %s]" % (sh, lower_bound, upper_bound)) elif lower_bound == 1: sh = "a positive %s" % self.number_name elif upper_bound == -1: sh = "a negative %s" % self.number_name elif lower_bound == 0: sh = "a non-negative %s" % self.number_name elif upper_bound == 0: sh = "a non-positive %s" % self.number_name elif upper_bound is not None: sh = "%s <= %s" % (self.number_name, upper_bound) elif lower_bound is not None: sh = "%s >= %s" % (self.number_name, lower_bound) self.syntactic_help = sh def Convert(self, argument): __pychecker__ = 'no-returnvalues' if type(argument) == str: base = 10 if len(argument) > 2 and argument[0] == "0" and argument[1] == "x": base = 16 return int(argument, base) else: return int(argument) def Type(self): return 'int' def DEFINE_integer(name, default, help, lower_bound=None, upper_bound=None, flag_values=FLAGS, **args): """Registers a flag whose value must be an integer. If lower_bound, or upper_bound are set, then this flag must be within the given range. """ parser = IntegerParser(lower_bound, upper_bound) serializer = ArgumentSerializer() DEFINE(parser, name, default, help, flag_values, serializer, **args) _RegisterBoundsValidatorIfNeeded(parser, name, flag_values=flag_values) # # ENUM FLAGS # class EnumParser(ArgumentParser): """Parser of a string enum value (a string value from a given set). If enum_values (see below) is not specified, any string is allowed. """ def __init__(self, enum_values=None): super(EnumParser, self).__init__() self.enum_values = enum_values def Parse(self, argument): if self.enum_values and argument not in self.enum_values: raise ValueError("value should be one of <%s>" % "|".join(self.enum_values)) return argument def Type(self): return 'string enum' class EnumFlag(Flag): """Basic enum flag; its value can be any string from list of enum_values.""" def __init__(self, name, default, help, enum_values=None, short_name=None, **args): enum_values = enum_values or [] p = EnumParser(enum_values) g = ArgumentSerializer() Flag.__init__(self, p, g, name, default, help, short_name, **args) if not self.help: self.help = "an enum string" self.help = "<%s>: %s" % ("|".join(enum_values), self.help) def _WriteCustomInfoInXMLFormat(self, outfile, indent): for enum_value in self.parser.enum_values: _WriteSimpleXMLElement(outfile, 'enum_value', enum_value, indent) def DEFINE_enum(name, default, enum_values, help, flag_values=FLAGS, **args): """Registers a flag whose value can be any string from enum_values.""" DEFINE_flag(EnumFlag(name, default, help, enum_values, ** args), flag_values) # # LIST FLAGS # class BaseListParser(ArgumentParser): """Base class for a parser of lists of strings. To extend, inherit from this class; from the subclass __init__, call BaseListParser.__init__(self, token, name) where token is a character used to tokenize, and name is a description of the separator. """ def __init__(self, token=None, name=None): assert name super(BaseListParser, self).__init__() self._token = token self._name = name self.syntactic_help = "a %s separated list" % self._name def Parse(self, argument): if isinstance(argument, list): return argument elif argument == '': return [] else: return [s.strip() for s in argument.split(self._token)] def Type(self): return '%s separated list of strings' % self._name class ListParser(BaseListParser): """Parser for a comma-separated list of strings.""" def __init__(self): BaseListParser.__init__(self, ',', 'comma') def WriteCustomInfoInXMLFormat(self, outfile, indent): BaseListParser.WriteCustomInfoInXMLFormat(self, outfile, indent) _WriteSimpleXMLElement(outfile, 'list_separator', repr(','), indent) class WhitespaceSeparatedListParser(BaseListParser): """Parser for a whitespace-separated list of strings.""" def __init__(self): BaseListParser.__init__(self, None, 'whitespace') def WriteCustomInfoInXMLFormat(self, outfile, indent): BaseListParser.WriteCustomInfoInXMLFormat(self, outfile, indent) separators = list(string.whitespace) separators.sort() for ws_char in string.whitespace: _WriteSimpleXMLElement(outfile, 'list_separator', repr(ws_char), indent) def DEFINE_list(name, default, help, flag_values=FLAGS, **args): """Registers a flag whose value is a comma-separated list of strings.""" parser = ListParser() serializer = ListSerializer(',') DEFINE(parser, name, default, help, flag_values, serializer, **args) def DEFINE_spaceseplist(name, default, help, flag_values=FLAGS, **args): """Registers a flag whose value is a whitespace-separated list of strings. Any whitespace can be used as a separator. """ parser = WhitespaceSeparatedListParser() serializer = ListSerializer(' ') DEFINE(parser, name, default, help, flag_values, serializer, **args) # # MULTI FLAGS # class MultiFlag(Flag): """A flag that can appear multiple time on the command-line. The value of such a flag is a list that contains the individual values from all the appearances of that flag on the command-line. See the __doc__ for Flag for most behavior of this class. Only differences in behavior are described here: * The default value may be either a single value or a list of values. A single value is interpreted as the [value] singleton list. * The value of the flag is always a list, even if the option was only supplied once, and even if the default value is a single value """ def __init__(self, *args, **kwargs): Flag.__init__(self, *args, **kwargs) self.help += ';\n repeat this option to specify a list of values' def Parse(self, arguments): """Parses one or more arguments with the installed parser. Args: arguments: a single argument or a list of arguments (typically a list of default values); a single argument is converted internally into a list containing one item. """ if not isinstance(arguments, list): # Default value may be a list of values. Most other arguments # will not be, so convert them into a single-item list to make # processing simpler below. arguments = [arguments] if self.present: # keep a backup reference to list of previously supplied option values values = self.value else: # "erase" the defaults with an empty list values = [] for item in arguments: # have Flag superclass parse argument, overwriting self.value reference Flag.Parse(self, item) # also increments self.present values.append(self.value) # put list of option values back in the 'value' attribute self.value = values def Serialize(self): if not self.serializer: raise FlagsError("Serializer not present for flag %s" % self.name) if self.value is None: return '' s = '' multi_value = self.value for self.value in multi_value: if s: s += ' ' s += Flag.Serialize(self) self.value = multi_value return s def Type(self): return 'multi ' + self.parser.Type() def DEFINE_multi(parser, serializer, name, default, help, flag_values=FLAGS, **args): """Registers a generic MultiFlag that parses its args with a given parser. Auxiliary function. Normal users should NOT use it directly. Developers who need to create their own 'Parser' classes for options which can appear multiple times can call this module function to register their flags. """ DEFINE_flag(MultiFlag(parser, serializer, name, default, help, **args), flag_values) def DEFINE_multistring(name, default, help, flag_values=FLAGS, **args): """Registers a flag whose value can be a list of any strings. Use the flag on the command line multiple times to place multiple string values into the list. The 'default' may be a single string (which will be converted into a single-element list) or a list of strings. """ parser = ArgumentParser() serializer = ArgumentSerializer() DEFINE_multi(parser, serializer, name, default, help, flag_values, **args) def DEFINE_multi_int(name, default, help, lower_bound=None, upper_bound=None, flag_values=FLAGS, **args): """Registers a flag whose value can be a list of arbitrary integers. Use the flag on the command line multiple times to place multiple integer values into the list. The 'default' may be a single integer (which will be converted into a single-element list) or a list of integers. """ parser = IntegerParser(lower_bound, upper_bound) serializer = ArgumentSerializer() DEFINE_multi(parser, serializer, name, default, help, flag_values, **args) def DEFINE_multi_float(name, default, help, lower_bound=None, upper_bound=None, flag_values=FLAGS, **args): """Registers a flag whose value can be a list of arbitrary floats. Use the flag on the command line multiple times to place multiple float values into the list. The 'default' may be a single float (which will be converted into a single-element list) or a list of floats. """ parser = FloatParser(lower_bound, upper_bound) serializer = ArgumentSerializer() DEFINE_multi(parser, serializer, name, default, help, flag_values, **args) # Now register the flags that we want to exist in all applications. # These are all defined with allow_override=1, so user-apps can use # these flagnames for their own purposes, if they want. DEFINE_flag(HelpFlag()) DEFINE_flag(HelpshortFlag()) DEFINE_flag(HelpXMLFlag()) # Define special flags here so that help may be generated for them. # NOTE: Please do NOT use _SPECIAL_FLAGS from outside this module. _SPECIAL_FLAGS = FlagValues() DEFINE_string( 'flagfile', "", "Insert flag definitions from the given file into the command line.", _SPECIAL_FLAGS) DEFINE_string( 'undefok', "", "comma-separated list of flag names that it is okay to specify " "on the command line even if the program does not define a flag " "with that name. IMPORTANT: flags in this list that have " "arguments MUST use the --flag=value format.", _SPECIAL_FLAGS)

gpl-3.0

gkioxari/RstarCNN

lib/random_data_layer/layer.py

1

6391

# -------------------------------------------------------- # Fast R-CNN # Copyright (c) 2015 Microsoft # Licensed under The MIT License [see LICENSE for details] # Written by Ross Girshick # -------------------------------------------------------- # -------------------------------------------------------- # R*CNN # Written by Georgia Gkioxari, 2015. # See LICENSE in the project root for license information. # -------------------------------------------------------- """The data layer used during training to train a R*CNN network. RandomDataLayer implements a Caffe Python layer. """ import caffe from fast_rcnn.config import cfg from random_data_layer.minibatch import get_minibatch import numpy as np import yaml from multiprocessing import Process, Queue class RandomDataLayer(caffe.Layer): """Fast R-CNN data layer used for training.""" def _shuffle_roidb_inds(self): """Randomly permute the training roidb.""" self._perm = np.random.permutation(np.arange(len(self._roidb))) self._cur = 0 def _get_next_minibatch_inds(self): """Return the roidb indices for the next minibatch.""" if self._cur + cfg.TRAIN.IMS_PER_BATCH >= len(self._roidb): self._shuffle_roidb_inds() db_inds = self._perm[self._cur:self._cur + cfg.TRAIN.IMS_PER_BATCH] self._cur += cfg.TRAIN.IMS_PER_BATCH return db_inds def _get_next_minibatch(self): """Return the blobs to be used for the next minibatch. If cfg.TRAIN.USE_PREFETCH is True, then blobs will be computed in a separate process and made available through self._blob_queue. """ if cfg.TRAIN.USE_PREFETCH: return self._blob_queue.get() else: db_inds = self._get_next_minibatch_inds() minibatch_db = [self._roidb[i] for i in db_inds] return get_minibatch(minibatch_db, self._num_classes) def set_roidb(self, roidb): """Set the roidb to be used by this layer during training.""" self._roidb = roidb self._shuffle_roidb_inds() if cfg.TRAIN.USE_PREFETCH: self._blob_queue = Queue(10) self._prefetch_process = BlobFetcher(self._blob_queue, self._roidb, self._num_classes) self._prefetch_process.start() # Terminate the child process when the parent exists def cleanup(): print 'Terminating BlobFetcher' self._prefetch_process.terminate() self._prefetch_process.join() import atexit atexit.register(cleanup) def setup(self, bottom, top): """Setup the RoIDataLayer.""" # parse the layer parameter string, which must be valid YAML layer_params = yaml.load(self.param_str_) self._num_classes = layer_params['num_classes'] self._name_to_top_map = { 'data': 0, 'rois': 1, 'secondary_rois': 2, 'labels': 3} # data blob: holds a batch of N images, each with 3 channels # The height and width (100 x 100) are dummy values top[0].reshape(1, 3, 100, 100) # rois blob: holds R regions of interest, each is a 5-tuple # (n, x1, y1, x2, y2) specifying an image batch index n and a # rectangle (x1, y1, x2, y2) top[1].reshape(1, 5) # secondary rois blob: holds R*C regions of interest, where C is # the number of secondary regions # (n, x1, y1, x2, y2) specifying an image batch top[2].reshape(1, 5) # labels blob: R categorical labels in [0, ..., K] for K foreground # classes plus background top[3].reshape(1) if cfg.TRAIN.BBOX_REG: self._name_to_top_map['bbox_targets'] = 4 self._name_to_top_map['bbox_loss_weights'] = 5 # bbox_targets blob: R bounding-box regression targets with 4 # targets per class top[4].reshape(1, self._num_classes * 4) # bbox_loss_weights blob: At most 4 targets per roi are active; # thisbinary vector sepcifies the subset of active targets top[5].reshape(1, self._num_classes * 4) def forward(self, bottom, top): """Get blobs and copy them into this layer's top blob vector.""" blobs = self._get_next_minibatch() for blob_name, blob in blobs.iteritems(): top_ind = self._name_to_top_map[blob_name] # Reshape net's input blobs top[top_ind].reshape(*(blob.shape)) # Copy data into net's input blobs top[top_ind].data[...] = blob.astype(np.float32, copy=False) def backward(self, top, propagate_down, bottom): """This layer does not propagate gradients.""" pass def reshape(self, bottom, top): """Reshaping happens during the call to forward.""" pass class BlobFetcher(Process): """Experimental class for prefetching blobs in a separate process.""" def __init__(self, queue, roidb, num_classes): super(BlobFetcher, self).__init__() self._queue = queue self._roidb = roidb self._num_classes = num_classes self._perm = None self._cur = 0 self._shuffle_roidb_inds() # fix the random seed for reproducibility np.random.seed(cfg.RNG_SEED) def _shuffle_roidb_inds(self): """Randomly permute the training roidb.""" # TODO(rbg): remove duplicated code self._perm = np.random.permutation(np.arange(len(self._roidb))) self._cur = 0 def _get_next_minibatch_inds(self): """Return the roidb indices for the next minibatch.""" # TODO(rbg): remove duplicated code if self._cur + cfg.TRAIN.IMS_PER_BATCH >= len(self._roidb): self._shuffle_roidb_inds() db_inds = self._perm[self._cur:self._cur + cfg.TRAIN.IMS_PER_BATCH] self._cur += cfg.TRAIN.IMS_PER_BATCH return db_inds def run(self): print 'BlobFetcher started' while True: db_inds = self._get_next_minibatch_inds() minibatch_db = [self._roidb[i] for i in db_inds] blobs = get_minibatch(minibatch_db, self._num_classes) self._queue.put(blobs)

bsd-2-clause

puruckertom/ubertool

ubertool/sam_old/sam_multiprocessing.py

1

8682

__author__ = 'jflaisha' from concurrent.futures import ProcessPoolExecutor as Pool from functools import partial import logging import multiprocessing #import numpy as np import os import sys import sam_callable try: import superprzm # Import superprzm.dll / .so _dll_loaded = True except ImportError as e: logging.exception(e) _dll_loaded = False curr_path = os.path.abspath(os.path.dirname(__file__)) mp_logger = multiprocessing.log_to_stderr() def multiprocessing_setup(): """ Create the ProcessPoolExecutor object with the max number of concurrent workers equal to the number of cores of the machine running this script. :return: ProcessPoolExecutor object reference """ nproc = multiprocessing.cpu_count() # Get number of processors available on machine if nproc > 16: # Force 'nproc' to be 16 nproc = 16 try: host_name = os.uname()[1] if host_name == 'ord-uber-vm005': # Force Server 5 to use 16 processes to avoid the memdump error when using a process pool with less max_workers than total number of processes nproc = 16 except Exception as e: return Pool(max_workers=nproc) # Set number of workers to equal the number of processors available on machine class SamModelCaller(object): """ Class for calling Fortran version of SAM. """ def __init__(self, jid, name_temp, no_of_processes=16): """ Constructor for SamModelCaller class. :param name_temp: string :param number_of_rows_list: list :param no_of_processes: int """ self.sam_bin_path = os.path.join(curr_path, 'bin') self.jid = jid self.name_temp = name_temp self.no_of_processes = no_of_processes def sam_multiprocessing(self): """ Submits jobs (SAM runs) to the worker pool. """ try: import subprocess32 as subprocess # Use subprocess32 for Linux (Python 3.2 backport) except ImportError: import subprocess try: # Ensure that the ProcessPoolExecutor object has been instantiated if pool is None: pass # 'pool' is already defined by multiprocessing_setup() except NameError: pool = multiprocessing_setup() # Split master HUC CSV into sections and return a list containing the number of rows in each section (sequentially) try: self.number_of_rows_list = self.split_csv() except Exception as e: self.number_of_rows_list = [306, 306, 306, 306, 306, 306, 306, 306, 306, 306, 306, 306, 306, 306, 306, 320] for x in range(self.no_of_processes): # Loop over all the 'no_of_processes' to fill the process pool.submit( daily_conc_callable, self.jid, # 'jid' of SAM run self.sam_bin_path, # Absolute path to the SAM bin folder self.name_temp, # Temporary path name for this SuperPRZM run self.two_digit(x), # Section number, as two digits, of this set of HUCs for the SuperPRZM run self.number_of_rows_list[x] # Number of 'rows'/HUC12s for this section of HUCs for the SuperPRZM run ).add_done_callback( partial(callback_daily, self.two_digit(x)) ) # Destroy the Pool object which hosts the processes when the pending Futures objects are finished, # but do not wait until all Futures are done to have this function return # pool.shutdown(wait=False) # Non-blocking pool.shutdown() # Blocking def split_csv(self): """ Load master CSV for SuperPRZM run as Pandas DataFrame and slice it based on the number of Futures objects created to execute it. (Currently Fortran is set to accept only a 1 char digit; therefore, the max number here is 9) :param number: int (1 - 9) :param curr_path: String; absolute path to this module :return: list; list with length equal number of csv sections, where each index is number of rows in section """ import pandas as pd df = pd.read_csv(os.path.join( self.sam_bin_path, 'EcoRecipes_huc12', 'recipe_combos2012', 'huc12_outlets_metric.csv'), dtype={'HUC_12': object, 'COMID': object} # Set columns 'HUC_12' & 'COMID' to 'object' (~eq. to string) ) # This preserves any leading zeros present in the HUC12_IDs if self.no_of_processes > 99: self.no_of_processes = 99 if self.no_of_processes < 1: self.no_of_processes = 1 try: rows_per_sect = df.shape[0] / self.no_of_processes except Exception as e: self.no_of_processes = 1 rows_per_sect = df.shape[0] / self.no_of_processes os.makedirs(os.path.join(self.sam_bin_path, self.name_temp, 'EcoRecipes_huc12', 'recipe_combos2012')) number_of_rows_list = [] i = 1 while i <= self.no_of_processes: if i == 1: # First slice df_slice = df[:rows_per_sect] elif i == self.no_of_processes: # End slice: slice to the end of the DataFrame df_slice = df[((i - 1) * rows_per_sect):] else: # Middle slices (not first or last) df_slice = df[((i - 1) * rows_per_sect):i * rows_per_sect] number_of_rows_list.append(len(df_slice)) # Save the number of rows for each CSV to be passed to SuperPRZM df_slice.to_csv(os.path.join( self.sam_bin_path, self.name_temp, 'EcoRecipes_huc12', 'recipe_combos2012', 'huc12_outlets_metric_' + self.two_digit(i - 1) + '.csv' ), index=False) i += 1 return number_of_rows_list def two_digit(self, x): """ Convert "1" to "01", etc., up to 9. Value of x has 1 added to it; therefore, a zero-based sequence is expected. :param x: int :return: String, two digit representation of x + 1 if x < 9 """ if x < 9: number_string = "0" + str(x + 1) else: number_string = str(x + 1) return number_string def daily_conc_callable(jid, sam_bin_path, name_temp, section, array_size=320): """ :param jid: :param sam_bin_path: :param name_temp: :param section: :param array_size: :return: """ # TODO: Remove these; left to show how it was previously done while testing callable # return subprocess.Popen(args).wait() # Identical to subprocess.call() # return subprocess.Popen(args, stdout=subprocess.PIPE).communicate() # try: sam_callable.run(jid, sam_bin_path, name_temp, section, int(array_size)) except Exception as e: mp_logger.exception(e) def callback_daily(section, future): """ Daily callback. :param section: :param future: :return: """ # def create_number_of_rows_list(list_string): """ Create rows. :param list_string: :return: """ return list_string.split() def main(): """ When run from command line this script takes 1 mandatory arguments and 2 optional arguments. Mandatory arg: name_temp, string. Random 6 character string for run to generate temporary run directory. Optional args: number_of_rows_list, list. If using a dataset that has already been processed by the split_csv() method, this is a list with a length equal to the number of csv sections created (which is equal to the number of workers). Each item in the list is the number of rows in that csv section, sequentially, where index 0 is the 1st csv section. no_of_processes, int. Total number of processes that will be used to complete the run. This is also equal to the number of sections the csv will be dividing into and the length of the number_of_rows_list optional argument. :return: """ # Get command line arguments jid = sys.argv[1] name_temp = sys.argv[2] if len(sys.argv) == 4: # 'no_of_processes' is an optional command line argument that defaults to 16 if not given no_of_processes = int(sys.argv[3]) sam = SamModelCaller(jid, name_temp, no_of_processes) else: sam = SamModelCaller(jid, name_temp) sam.sam_multiprocessing() if __name__ == "__main__": # Create Process Pool pool = multiprocessing_setup() main() sys.exit()

unlicense

chokribr/invenio

invenio/modules/oauthclient/contrib/orcid.py

13

6448

# -*- coding: utf-8 -*- # # This file is part of Invenio. # Copyright (C) 2014, 2015 CERN. # # Invenio is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # Invenio 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Invenio; if not, write to the Free Software Foundation, Inc., # 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. """Pre-configured remote application for enabling sign in/up with ORCID. **Usage:** 1. Edit your configuration and add: .. code-block:: python from invenio.modules.oauthclient.contrib import orcid OAUTHCLIENT_REMOTE_APPS = dict( orcid=orcid.REMOTE_APP, ) ORCID_APP_CREDENTIALS = dict( consumer_key="changeme", consumer_secret="changeme", ) Note, if you want to use the ORCID sandbox, use ``orcid.REMOTE_SANDBOX_APP`` instead of ``orcid.REMOTE_APP``. 2. Register a new application with ORCID. When registering the application ensure that the *Redirect URI* points to: ``CFG_SITE_SECURE_URL/oauth/authorized/orcid/`` (note, ORCID does not allow localhost to be used, thus testing on development machines is somewhat complicated by this). 3. Grab the *Client ID* and *Client Secret* after registering the application and add them to your instance configuration (``invenio.cfg``): .. code-block:: python ORCID_APP_CREDENTIALS = dict( consumer_key="<CLIENT ID>", consumer_secret="<CLIENT SECRET>", ) 4. Now go to ``CFG_SITE_SECURE_URL/oauth/login/orcid/`` (e.g. http://localhost:4000/oauth/login/orcid/) 5. Also, you should see ORCID listed under Linked accounts: http://localhost:4000//account/settings/linkedaccounts/ By default the ORCID module will try first look if a link already exists between a ORCID account and a user. If no link is found, the user is asked to provide an email address to sign-up. In templates you can add a sign in/up link: .. code-block:: jinja <a href="{{url_for('oauthclient.login', remote_app='orcid')}}"> Sign in with ORCID </a> """ import copy from flask import current_app, redirect, url_for from flask_login import current_user from invenio.ext.sqlalchemy.utils import session_manager REMOTE_APP = dict( title='ORCID', description='Connecting Research and Researchers.', icon='', authorized_handler="invenio.modules.oauthclient.handlers" ":authorized_signup_handler", disconnect_handler="invenio.modules.oauthclient.contrib.orcid" ":disconnect_handler", signup_handler=dict( info="invenio.modules.oauthclient.contrib.orcid:account_info", setup="invenio.modules.oauthclient.contrib.orcid:account_setup", view="invenio.modules.oauthclient.handlers:signup_handler", ), params=dict( request_token_params={'scope': '/authenticate', 'show_login': 'true'}, base_url='https://pub.orcid.org/v1.2/', request_token_url=None, access_token_url="https://pub.orcid.org/oauth/token", access_token_method='POST', authorize_url="https://orcid.org/oauth/authorize", app_key="ORCID_APP_CREDENTIALS", content_type="application/json", ) ) """ ORCID Remote Application. """ REMOTE_SANDBOX_APP = copy.deepcopy(REMOTE_APP) """ORCID Sandbox Remote Application.""" REMOTE_SANDBOX_APP['params'].update(dict( base_url="https://api.sandbox.orcid.org/", access_token_url="https://api.sandbox.orcid.org/oauth/token", authorize_url="https://sandbox.orcid.org/oauth/authorize#show_login", )) def account_info(remote, resp): """Retrieve remote account information used to find local user.""" account_info = dict(external_id=resp.get("orcid"), external_method="orcid") return account_info def disconnect_handler(remote, *args, **kwargs): """Handle unlinking of remote account.""" from invenio.modules.oauthclient.utils import oauth_unlink_external_id from invenio.modules.oauthclient.models import RemoteAccount if not current_user.is_authenticated(): return current_app.login_manager.unauthorized() account = RemoteAccount.get(user_id=current_user.get_id(), client_id=remote.consumer_key) orcid = account.extra_data.get('orcid') if orcid: oauth_unlink_external_id(dict(id=orcid, method='orcid')) if account: account.delete() return redirect(url_for('oauthclient_settings.index')) @session_manager def account_setup(remote, token, resp): """Perform additional setup after user have been logged in.""" from invenio.modules.oauthclient.utils import oauth_link_external_id from invenio.ext.sqlalchemy import db # Retrieve ORCID from response. orcid = resp.get("orcid") # Set ORCID in extra_data. token.remote_account.extra_data = {"orcid": orcid} user = token.remote_account.user # Create user <-> external id link. oauth_link_external_id(user, dict(id=orcid, method="orcid")) # Fill user full name if not already set if user and not any([user.given_names, user.family_name]): # Query ORCID to get the real name response = remote.get("{0}/orcid-bio".format(orcid), headers={'Accept': 'application/orcid+json'}, content_type="application/json") if response.status == 200: try: name = response.data["orcid-profile"]["orcid-bio"][ "personal-details"] user.given_names = name["given-names"]["value"] user.family_name = name["family-name"]["value"] except KeyError: current_app.logger.exception( "Unexpected return format from ORCID: {0}".format( repr(response.data))) return db.session.add(user) # Refresh user cache current_user.reload()

gpl-2.0

bdoin/GCompris-site

activity/color/closure/closure/bin/build/source.py

18

2723

# Copyright 2009 The Closure Library 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. """Scans a source JS file for its provided and required namespaces. Simple class to scan a JavaScript file and express its dependencies. """ import re _BASE_REGEX_STRING = '^\s*goog\.%s\(\s*[\'"](.+)[\'"]\s*\)' _PROVIDE_REGEX = re.compile(_BASE_REGEX_STRING % 'provide') _REQUIRES_REGEX = re.compile(_BASE_REGEX_STRING % 'require') # This line identifies base.js and should match the line in that file. _GOOG_BASE_LINE = ( 'var goog = goog || {}; // Identifies this file as the Closure base.') class Source(object): """Scans a JavaScript source for its provided and required namespaces.""" def __init__(self, source): """Initialize a source. Args: source: str, The JavaScript source. """ self.provides = set() self.requires = set() self._source = source self._ScanSource() def __str__(self): return 'Source %s' % self._path def GetSource(self): """Get the source as a string.""" return self._source def _ScanSource(self): """Fill in provides and requires by scanning the source.""" # TODO: Strip source comments first, as these might be in a comment # block. RegExes can be borrowed from other projects. source = self.GetSource() source_lines = source.splitlines() for line in source_lines: match = _PROVIDE_REGEX.match(line) if match: self.provides.add(match.group(1)) match = _REQUIRES_REGEX.match(line) if match: self.requires.add(match.group(1)) # Closure's base file implicitly provides 'goog'. for line in source_lines: if line == _GOOG_BASE_LINE: if len(self.provides) or len(self.requires): raise Exception( 'Base files should not provide or require namespaces.') self.provides.add('goog') def GetFileContents(path): """Get a file's contents as a string. Args: path: str, Path to file. Returns: str, Contents of file. Raises: IOError: An error occurred opening or reading the file. """ fileobj = open(path) try: return fileobj.read() finally: fileobj.close()

gpl-3.0

befelix/scipy

scipy/stats/__init__.py

5

9236

""" ========================================== Statistical functions (:mod:`scipy.stats`) ========================================== .. module:: scipy.stats This module contains a large number of probability distributions as well as a growing library of statistical functions. Each univariate distribution is an instance of a subclass of `rv_continuous` (`rv_discrete` for discrete distributions): .. autosummary:: :toctree: generated/ rv_continuous rv_discrete rv_histogram Continuous distributions ======================== .. autosummary:: :toctree: generated/ alpha -- Alpha anglit -- Anglit arcsine -- Arcsine argus -- Argus beta -- Beta betaprime -- Beta Prime bradford -- Bradford burr -- Burr (Type III) burr12 -- Burr (Type XII) cauchy -- Cauchy chi -- Chi chi2 -- Chi-squared cosine -- Cosine dgamma -- Double Gamma dweibull -- Double Weibull erlang -- Erlang expon -- Exponential exponnorm -- Exponentially Modified Normal exponweib -- Exponentiated Weibull exponpow -- Exponential Power f -- F (Snecdor F) fatiguelife -- Fatigue Life (Birnbaum-Saunders) fisk -- Fisk foldcauchy -- Folded Cauchy foldnorm -- Folded Normal frechet_r -- Frechet Right Sided, Extreme Value Type II (Extreme LB) or weibull_min frechet_l -- Frechet Left Sided, Weibull_max genlogistic -- Generalized Logistic gennorm -- Generalized normal genpareto -- Generalized Pareto genexpon -- Generalized Exponential genextreme -- Generalized Extreme Value gausshyper -- Gauss Hypergeometric gamma -- Gamma gengamma -- Generalized gamma genhalflogistic -- Generalized Half Logistic gilbrat -- Gilbrat gompertz -- Gompertz (Truncated Gumbel) gumbel_r -- Right Sided Gumbel, Log-Weibull, Fisher-Tippett, Extreme Value Type I gumbel_l -- Left Sided Gumbel, etc. halfcauchy -- Half Cauchy halflogistic -- Half Logistic halfnorm -- Half Normal halfgennorm -- Generalized Half Normal hypsecant -- Hyperbolic Secant invgamma -- Inverse Gamma invgauss -- Inverse Gaussian invweibull -- Inverse Weibull johnsonsb -- Johnson SB johnsonsu -- Johnson SU kappa4 -- Kappa 4 parameter kappa3 -- Kappa 3 parameter ksone -- Kolmogorov-Smirnov one-sided (no stats) kstwobign -- Kolmogorov-Smirnov two-sided test for Large N (no stats) laplace -- Laplace levy -- Levy levy_l levy_stable logistic -- Logistic loggamma -- Log-Gamma loglaplace -- Log-Laplace (Log Double Exponential) lognorm -- Log-Normal lomax -- Lomax (Pareto of the second kind) maxwell -- Maxwell mielke -- Mielke's Beta-Kappa nakagami -- Nakagami ncx2 -- Non-central chi-squared ncf -- Non-central F nct -- Non-central Student's T norm -- Normal (Gaussian) pareto -- Pareto pearson3 -- Pearson type III powerlaw -- Power-function powerlognorm -- Power log normal powernorm -- Power normal rdist -- R-distribution reciprocal -- Reciprocal rayleigh -- Rayleigh rice -- Rice recipinvgauss -- Reciprocal Inverse Gaussian semicircular -- Semicircular skewnorm -- Skew normal t -- Student's T trapz -- Trapezoidal triang -- Triangular truncexpon -- Truncated Exponential truncnorm -- Truncated Normal tukeylambda -- Tukey-Lambda uniform -- Uniform vonmises -- Von-Mises (Circular) vonmises_line -- Von-Mises (Line) wald -- Wald weibull_min -- Minimum Weibull (see Frechet) weibull_max -- Maximum Weibull (see Frechet) wrapcauchy -- Wrapped Cauchy Multivariate distributions ========================== .. autosummary:: :toctree: generated/ multivariate_normal -- Multivariate normal distribution matrix_normal -- Matrix normal distribution dirichlet -- Dirichlet wishart -- Wishart invwishart -- Inverse Wishart multinomial -- Multinomial distribution special_ortho_group -- SO(N) group ortho_group -- O(N) group unitary_group -- U(N) gropu random_correlation -- random correlation matrices Discrete distributions ====================== .. autosummary:: :toctree: generated/ bernoulli -- Bernoulli binom -- Binomial boltzmann -- Boltzmann (Truncated Discrete Exponential) dlaplace -- Discrete Laplacian geom -- Geometric hypergeom -- Hypergeometric logser -- Logarithmic (Log-Series, Series) nbinom -- Negative Binomial planck -- Planck (Discrete Exponential) poisson -- Poisson randint -- Discrete Uniform skellam -- Skellam zipf -- Zipf Statistical functions ===================== Several of these functions have a similar version in scipy.stats.mstats which work for masked arrays. .. autosummary:: :toctree: generated/ describe -- Descriptive statistics gmean -- Geometric mean hmean -- Harmonic mean kurtosis -- Fisher or Pearson kurtosis kurtosistest -- mode -- Modal value moment -- Central moment normaltest -- skew -- Skewness skewtest -- kstat -- kstatvar -- tmean -- Truncated arithmetic mean tvar -- Truncated variance tmin -- tmax -- tstd -- tsem -- variation -- Coefficient of variation find_repeats trim_mean .. autosummary:: :toctree: generated/ cumfreq histogram2 histogram itemfreq percentileofscore scoreatpercentile relfreq .. autosummary:: :toctree: generated/ binned_statistic -- Compute a binned statistic for a set of data. binned_statistic_2d -- Compute a 2-D binned statistic for a set of data. binned_statistic_dd -- Compute a d-D binned statistic for a set of data. .. autosummary:: :toctree: generated/ obrientransform signaltonoise bayes_mvs mvsdist sem zmap zscore iqr .. autosummary:: :toctree: generated/ sigmaclip threshold trimboth trim1 .. autosummary:: :toctree: generated/ f_oneway pearsonr spearmanr pointbiserialr kendalltau weightedtau linregress theilslopes f_value .. autosummary:: :toctree: generated/ ttest_1samp ttest_ind ttest_ind_from_stats ttest_rel kstest chisquare power_divergence ks_2samp mannwhitneyu tiecorrect rankdata ranksums wilcoxon kruskal friedmanchisquare combine_pvalues ss square_of_sums jarque_bera .. autosummary:: :toctree: generated/ ansari bartlett levene shapiro anderson anderson_ksamp binom_test fligner median_test mood .. autosummary:: :toctree: generated/ boxcox boxcox_normmax boxcox_llf entropy .. autosummary:: :toctree: generated/ chisqprob betai Circular statistical functions ============================== .. autosummary:: :toctree: generated/ circmean circvar circstd Contingency table functions =========================== .. autosummary:: :toctree: generated/ chi2_contingency contingency.expected_freq contingency.margins fisher_exact Plot-tests ========== .. autosummary:: :toctree: generated/ ppcc_max ppcc_plot probplot boxcox_normplot Masked statistics functions =========================== .. toctree:: stats.mstats Univariate and multivariate kernel density estimation (:mod:`scipy.stats.kde`) ============================================================================== .. autosummary:: :toctree: generated/ gaussian_kde For many more stat related functions install the software R and the interface package rpy. """ from __future__ import division, print_function, absolute_import from .stats import * from .distributions import * from .morestats import * from ._binned_statistic import * from .kde import gaussian_kde from . import mstats from .contingency import chi2_contingency from ._multivariate import * __all__ = [s for s in dir() if not s.startswith("_")] # Remove dunders. from numpy.testing import Tester test = Tester().test

bsd-3-clause

kvarkson/django-pdf-to-image-converter

1.4/DjangoPdfToImageConverter/pdfconverter/extra.py

3

1635

from django.db.models import FileField from django.forms import forms from django.template.defaultfilters import filesizeformat from django.utils.translation import ugettext_lazy as _ class ContentTypeRestrictedFileField(FileField): """ Same as FileField, but you can specify: * content_types - list containing allowed content_types. Example: ['application/pdf', 'image/jpeg'] * max_upload_size - a number indicating the maximum file size allowed for upload. 2.5MB - 2621440 5MB - 5242880 10MB - 10485760 20MB - 20971520 50MB - 5242880 100MB 104857600 250MB - 214958080 500MB - 429916160 """ def __init__(self, *args, **kwargs): self.content_types = kwargs.pop("content_types") self.max_upload_size = kwargs.pop("max_upload_size") super(ContentTypeRestrictedFileField, self).__init__(*args, **kwargs) def clean(self, *args, **kwargs): data = super(ContentTypeRestrictedFileField, self).clean(*args, **kwargs) file = data.file try: content_type = file.content_type if content_type in self.content_types: if file._size > self.max_upload_size: raise forms.ValidationError(_('Please keep filesize under %s. Current filesize %s') % (filesizeformat(self.max_upload_size), filesizeformat(file._size))) else: raise forms.ValidationError(_('Filetype not supported.')) except AttributeError: pass return data

mit

repotvsupertuga/repo

script.module.gdrive/default.py

1

92648

''' CloudService XBMC Plugin Copyright (C) 2013-2014 ddurdle This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. ''' # cloudservice - required python modules import sys import urllib import re import os KODI = True if re.search(re.compile('.py', re.IGNORECASE), sys.argv[0]) is not None: KODI = False if KODI: # cloudservice - standard XBMC modules import xbmc, xbmcgui, xbmcplugin, xbmcaddon, xbmcvfs else: from resources.libgui import xbmcaddon from resources.libgui import xbmcgui # common routines from resources.lib import kodi_common # global variables import addon_parameters addon = addon_parameters.addon cloudservice3 = addon_parameters.cloudservice3 cloudservice2 = addon_parameters.cloudservice2 cloudservice1 = addon_parameters.cloudservice1 #*** testing - gdrive from resources.lib import tvWindow from resources.lib import gSpreadsheets from resources.lib import gSheets_api4 ##** # cloudservice - standard modules #from resources.lib import gdrive #from resources.lib import gdrive_api2 from resources.lib import cloudservice from resources.lib import authorization from resources.lib import folder from resources.lib import teamdrive from resources.lib import file from resources.lib import offlinefile from resources.lib import package from resources.lib import mediaurl from resources.lib import crashreport from resources.lib import gPlayer from resources.lib import settings from resources.lib import cache from resources.lib import TMDB #global variables PLUGIN_URL = sys.argv[0] plugin_handle = int(sys.argv[1]) plugin_queries = settings.parse_query(sys.argv[2][1:]) addon_dir = xbmc.translatePath( addon.getAddonInfo('path') ) kodi_common.debugger() # cloudservice - create settings module settings = settings.settings(addon) # retrieve settings user_agent = settings.getSetting('user_agent') #obsolete, replace, revents audio from streaming #if user_agent == 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)': # addon.setSetting('user_agent', 'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/532.0 (KHTML, like Gecko) Chrome/3.0.195.38 Safari/532.0') mode = settings.getParameter('mode','main') # make mode case-insensitive mode = mode.lower() #*** old - gdrive # allow for playback of public videos without authentication if (mode == 'streamurl'): authenticate = False else: authenticate = True ##** instanceName = '' try: instanceName = (plugin_queries['instance']).lower() except: pass # cloudservice - content type contextType = settings.getParameter('content_type') #support encfs? encfs = settings.getParameter('encfs', False) contentType = kodi_common.getContentType(contextType,encfs) xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_LABEL) # xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_TRACKNUM) xbmcplugin.addSortMethod(int(sys.argv[1]), xbmcplugin.SORT_METHOD_SIZE) numberOfAccounts = kodi_common.numberOfAccounts(addon_parameters.PLUGIN_NAME) invokedUsername = settings.getParameter('username') # cloudservice - utilities ### if mode == 'dummy' or mode == 'delete' or mode == 'enroll': kodi_common.accountActions(addon, addon_parameters.PLUGIN_NAME, mode, instanceName, numberOfAccounts) #create strm files elif mode == 'buildstrm': silent = settings.getParameter('silent', settings.getSetting('strm_silent',0)) if silent == '': silent = 0 try: path = settings.getSetting('strm_path') except: path = xbmcgui.Dialog().browse(0,addon.getLocalizedString(30026), 'files','',False,False,'') addon.setSetting('strm_path', path) if path == '': path = xbmcgui.Dialog().browse(0,addon.getLocalizedString(30026), 'files','',False,False,'') addon.setSetting('strm_path', path) if path != '': returnPrompt = xbmcgui.Dialog().yesno(addon.getLocalizedString(30000), addon.getLocalizedString(30027) + '\n'+path + '?') if path != '' and returnPrompt: if silent != 2: try: pDialog = xbmcgui.DialogProgressBG() pDialog.create(addon.getLocalizedString(30000), 'Building STRMs...') except: pass url = settings.getParameter('streamurl') url = re.sub('---', '&', url) title = settings.getParameter('title') type = int(settings.getParameter('type', 0)) if url != '': filename = path + '/' + title+'.strm' strmFile = xbmcvfs.File(filename, "w") strmFile.write(url+'\n') strmFile.close() else: folderID = settings.getParameter('folder') filename = settings.getParameter('filename') title = settings.getParameter('title') invokedUsername = settings.getParameter('username') encfs = settings.getParameter('encfs', False) encryptedPath = settings.getParameter('epath', '') dencryptedPath = settings.getParameter('dpath', '') if folderID != '': count = 1 loop = True while loop: instanceName = addon_parameters.PLUGIN_NAME+str(count) try: username = settings.getSetting(instanceName+'_username') if username == invokedUsername: #let's log in if ( settings.getSettingInt(instanceName+'_type',0)==0): service = cloudservice1(PLUGIN_URL,addon,instanceName, user_agent, settings) else: service = cloudservice2(PLUGIN_URL,addon,instanceName, user_agent, settings) loop = False except: service = cloudservice1(PLUGIN_URL,addon,instanceName, user_agent) break if count == numberOfAccounts: try: service except NameError: #fallback on first defined account if ( settings.getSettingInt(instanceName+'_type',0)==0): service = cloudservice1(PLUGIN_URL,addon,addon_parameters.PLUGIN_NAME+'1', user_agent, settings) else: service = cloudservice2(PLUGIN_URL,addon,addon_parameters.PLUGIN_NAME+'1', user_agent, settings) break count = count + 1 # encfs -- extract filename if encfs: extrapulatedFolderName = re.compile('([^/]+)/$') titleDecrypted = extrapulatedFolderName.match(dencryptedPath) if titleDecrypted is not None: title = titleDecrypted.group(1) if addon_parameters.spreadsheet and service.cloudResume == '2': spreadsheetFile = xbmcvfs.File(path + '/spreadsheet.tab', "w") service.buildSTRM(path + '/'+title,folderID, contentType=contentType, pDialog=pDialog, epath=encryptedPath, dpath=dencryptedPath, encfs=encfs, spreadsheetFile=spreadsheetFile) spreadsheetFile.close() else: service.buildSTRM(path + '/'+title,folderID, contentType=contentType, pDialog=pDialog, epath=encryptedPath, dpath=dencryptedPath, encfs=encfs) elif filename != '': if encfs: values = {'title': title, 'encfs': 'True', 'epath': encryptedPath, 'dpath': dencryptedPath, 'filename': filename, 'username': invokedUsername} # encfs -- extract filename extrapulatedFileName = re.compile('.*?/([^/]+)$') titleDecrypted = extrapulatedFileName.match(dencryptedPath) if titleDecrypted is not None: title = titleDecrypted.group(1) else: values = {'title': title, 'filename': filename, 'username': invokedUsername} if type == 1: url = PLUGIN_URL+'?mode=audio&'+urllib.urlencode(values) else: url = PLUGIN_URL+'?mode=video&'+urllib.urlencode(values) filename = path + '/' + title+'.strm' strmFile = xbmcvfs.File(filename, "w") strmFile.write(url+'\n') strmFile.close() else: count = 1 while True: instanceName = addon_parameters.PLUGIN_NAME+str(count) username = settings.getSetting(instanceName+'_username') if username != '' and username == invokedUsername: if ( settings.getSettingInt(instanceName+'_type',0)==0): service = cloudservice1(PLUGIN_URL,addon,instanceName, user_agent, settings) else: service = cloudservice2(PLUGIN_URL,addon,instanceName, user_agent, settings) service.buildSTRM(path + '/'+username, contentType=contentType, pDialog=pDialog, epath=encryptedPath, dpath=dencryptedPath, encfs=encfs) if count == numberOfAccounts: #fallback on first defined account try: service except NameError: #fallback on first defined account if ( settings.getSettingInt(instanceName+'_type',0)==0): service = cloudservice1(PLUGIN_URL,addon,addon_parameters.PLUGIN_NAME+'1', user_agent, settings) else: service = cloudservice2(PLUGIN_URL,addon,addon_parameters.PLUGIN_NAME+'1', user_agent, settings) break count = count + 1 if silent != 2: try: pDialog.update(100) pDialog.close() except: pass if silent == 0: xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30028)) xbmcplugin.endOfDirectory(plugin_handle) ### ### #STRM playback without instance name; use default if invokedUsername == '' and instanceName == '' and (mode == 'video' or mode == 'audio'): instanceName = addon_parameters.PLUGIN_NAME + str(settings.getSetting('account_default', 1)) instanceName = kodi_common.getInstanceName(addon, addon_parameters.PLUGIN_NAME, mode, instanceName, invokedUsername, numberOfAccounts, contextType) service = None if instanceName is None and (mode == 'index' or mode == 'main' or mode == 'offline'): service = None elif instanceName is None: service = cloudservice2(PLUGIN_URL,addon,'', user_agent, settings, authenticate=False) elif settings.getSettingInt(instanceName+'_type',0)==0 : service = cloudservice1(PLUGIN_URL,addon,instanceName, user_agent, settings) else: service = cloudservice2(PLUGIN_URL,addon,instanceName, user_agent, settings) #create strm files if mode == 'buildf2': import time currentDate = time.strftime("%Y%m%d") try: path = settings.getSetting('strm_path') except: pass if path != '': try: pDialog = xbmcgui.DialogProgressBG() pDialog.create(addon.getLocalizedString(30000), 'Building STRMs...') except: pass #service = gdrive_api2.gdrive(PLUGIN_URL,addon,instanceName, user_agent, settings) # try: addon.setSetting(instanceName + '_changedate', currentDate) service.buildSTRM2(path, contentType=contentType, pDialog=pDialog) # except: # pass try: pDialog.update(100) pDialog.close() except: pass xbmcplugin.endOfDirectory(plugin_handle) # options menu #if mode == 'main': # addMenu(PLUGIN_URL+'?mode=options','<< '+addon.getLocalizedString(30043)+' >>') if mode == 'offline': title = settings.getParameter('title') folderID = settings.getParameter('folder') folderName = settings.getParameter('foldername') mediaItems = kodi_common.getOfflineFileList(settings.getSetting('cache_folder')) if mediaItems: for offlinefile in mediaItems: kodi_common.addOfflineMediaFile(offlinefile) elif service is None: xbmcplugin.endOfDirectory(plugin_handle) #cloud_db actions elif mode == 'cloud_db': title = settings.getParameter('title') folderID = settings.getParameter('folder') folderName = settings.getParameter('foldername') filename = settings.getParameter('filename') action = settings.getParameter('action') mediaFile = file.file(filename, title, '', 0, '','') mediaFolder = folder.folder(folderID,folderName) package=package.package(mediaFile,mediaFolder) # TESTING if addon_parameters.spreadsheet and service.cloudResume == '2': if service.worksheetID == '': try: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) spreadsheets = service.gSpreadsheet.getSpreadsheetList() except: pass for title in spreadsheets.iterkeys(): if title == 'CLOUD_DB': worksheets = service.gSpreadsheet.getSpreadsheetWorksheets(spreadsheets[title]) for worksheet in worksheets.iterkeys(): if worksheet == 'db': service.worksheetID = worksheets[worksheet] addon.setSetting(instanceName + '_spreadsheet', service.worksheetID) break break # TESTING if addon_parameters.spreadsheet and service.cloudResume == '2': if service.gSpreadsheet is None: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) if action == 'watch': service.gSpreadsheet.setMediaStatus(service.worksheetID,package, watched=1) xbmc.executebuiltin("XBMC.Container.Refresh") elif action == 'queue': package.folder.id = 'QUEUED' service.gSpreadsheet.setMediaStatus(service.worksheetID,package) elif action == 'recentwatched' or action == 'recentstarted' or action == 'library' or action == 'queued': mediaItems = service.gSpreadsheet.updateMediaPackage(service.worksheetID, criteria=action) #ensure that folder view playback if contextType == '': contextType = 'video' if mediaItems: for item in mediaItems: if item.file is None: service.addDirectory(item.folder, contextType=contextType) else: service.addMediaFile(item, contextType=contextType) service.updateAuthorization(addon) #cloud_db actions elif mode == 'cloud_dbtest': title = settings.getParameter('title') folderID = settings.getParameter('folder') folderName = settings.getParameter('foldername') filename = settings.getParameter('filename') action = settings.getParameter('action') # s = gSheets_api4.gSheets_api4(service,addon, user_agent) # s.createSpreadsheet() # s.addRows() if action == 'library_menu': kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_genre&content_type='+str(contextType),'Genre') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_year&content_type='+str(contextType),'Year') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_title&content_type='+str(contextType),'Title') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_country&content_type='+str(contextType),'Countries') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_director&content_type='+str(contextType),'Directors') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_studio&content_type='+str(contextType),'Studio') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_resolution&content_type='+str(contextType),'Quality (Resolution)') else: mediaFile = file.file(filename, title, '', 0, '','') mediaFolder = folder.folder(folderID,folderName) package=package.package(mediaFile,mediaFolder) spreadsheet = None # TESTING if addon_parameters.spreadsheet: try: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) spreadsheets = service.gSpreadsheet.getSpreadsheetList() except: pass for t in spreadsheets.iterkeys(): if t == 'Movie2': worksheets = service.gSpreadsheet.getSpreadsheetWorksheets(spreadsheets[t]) for worksheet in worksheets.iterkeys(): if worksheet == 'db': spreadsheet = worksheets[worksheet] break break # TESTING if addon_parameters.spreadsheet: if service.gSpreadsheet is None: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) if action == 'watch': service.gSpreadsheet.setMediaStatus(service.worksheetID,package, watched=1) xbmc.executebuiltin("XBMC.Container.Refresh") elif action == 'queue': package.folder.id = 'QUEUED' service.gSpreadsheet.setMediaStatus(service.worksheetID,package) elif action == 'genre' or action == 'year' or action == 'title' or action == 'country' or action == 'director' or action == 'studio' or action == 'recentstarted' or 'library' in action or action == 'queued': if action == 'genre': mediaItems = service.gSpreadsheet.getMovies(spreadsheet, genre=title) elif action == 'year': mediaItems = service.gSpreadsheet.getMovies(spreadsheet, year=title) elif action == 'title': mediaItems = service.gSpreadsheet.getMovies(spreadsheet, title=title) elif action == 'resolution': mediaItems = service.gSpreadsheet.getMovies(spreadsheet, resolution=title) elif action == 'country': mediaItems = service.gSpreadsheet.getMovies(spreadsheet, country=title) elif action == 'director': mediaItems = service.gSpreadsheet.getMovies(spreadsheet, director=title) elif action == 'studio': mediaItems = service.gSpreadsheet.getMovies(spreadsheet, studio=title) elif action == 'library_title': mediaItems = service.gSpreadsheet.getTitle(spreadsheet) elif action == 'library_genre': mediaItems = service.gSpreadsheet.getGenre(spreadsheet) elif action == 'library_year': mediaItems = service.gSpreadsheet.getYear(spreadsheet) elif action == 'library_country': mediaItems = service.gSpreadsheet.getCountries(spreadsheet) elif action == 'library_director': mediaItems = service.gSpreadsheet.getDirector(spreadsheet) elif action == 'library_studio': mediaItems = service.gSpreadsheet.getStudio(spreadsheet) elif action == 'library_resolution': mediaItems = service.gSpreadsheet.getResolution(spreadsheet) #ensure that folder view playback if contextType == '': contextType = 'video' tmdb= TMDB.TMDB(service,addon, user_agent) if mediaItems: for item in mediaItems: if item.file is None: service.addDirectory(item.folder, contextType=contextType) else: # movieID = tmdb.movieSearch(item.file.title,item.file.year) # tmdb.movieDetails(movieID) service.addMediaFile(item, contextType=contextType) service.updateAuthorization(addon) #dump a list of videos available to play elif mode == 'main' or mode == 'index': folderID = settings.getParameter('folder', False) folderName = settings.getParameter('foldername', False) #ensure that folder view playback if contextType == '': contextType = 'video' # display option for all Videos/Music/Photos, across gdrive #** gdrive specific if mode == 'main': if ('gdrive' in addon_parameters.PLUGIN_NAME): if contentType in (2,4,7): kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=ALL&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+' '+addon.getLocalizedString(30030)+']') elif contentType == 1: kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=VIDEOMUSIC&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+' '+addon.getLocalizedString(30031)+']') elif contentType == 0: kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=VIDEO&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+' '+addon.getLocalizedString(30025)+']') elif contentType == 3: kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=MUSIC&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+' '+addon.getLocalizedString(30094)+']') elif contentType == 5: kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=PHOTO&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+' '+addon.getLocalizedString(30034)+']') elif contentType == 6: kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=PHOTOMUSIC&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+' '+addon.getLocalizedString(30032)+']') folderID = 'root' if ('gdrive' in addon_parameters.PLUGIN_NAME): # if (service.protocol != 2): # kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=STARRED-FILES&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+ ' '+addon.getLocalizedString(30095)+']') # kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=STARRED-FOLDERS&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+ ' '+addon.getLocalizedString(30096)+']') kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=SHARED&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+ ' '+addon.getLocalizedString(30098)+']') kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder=STARRED-FILESFOLDERS&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30018)+ ' '+addon.getLocalizedString(30097)+']') teamdrives = service.getTeamDrives(); for drive in teamdrives: kodi_common.addMenu(PLUGIN_URL+'?mode=index&folder='+str(drive.id)+'&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30200) + ' - ' + str(drive.title)+']') kodi_common.addMenu(PLUGIN_URL+'?mode=search&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30111)+']') kodi_common.addMenu(PLUGIN_URL+'?mode=buildstrm2&instance='+str(service.instanceName)+'&content_type='+str(contextType),'<Testing - manual run of change tracking build STRM>') if addon_parameters.testing_features: kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_dbtest&instance='+str(service.instanceName)+'&action=library_menu&content_type='+str(contextType),'[MOVIES]') #CLOUD_DB if 'gdrive' in addon_parameters.PLUGIN_NAME and service.gSpreadsheet is not None: kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_db&action=recentstarted&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30177)+' recently started]') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_db&action=recentwatched&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30177)+' recently watched]') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_db&action=library&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30177)+' library]') kodi_common.addMenu(PLUGIN_URL+'?mode=cloud_db&action=queued&instance='+str(service.instanceName)+'&content_type='+contextType,'['+addon.getLocalizedString(30177)+' queued]') ##** # cloudservice - validate service try: service except NameError: xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30051), addon.getLocalizedString(30052)) xbmc.log(addon.getLocalizedString(30050)+ addon_parameters.PLUGIN_NAME+'-login', xbmc.LOGERROR) xbmcplugin.endOfDirectory(plugin_handle) #if encrypted, get everything(as encrypted files will be of type application/ostream) if encfs: #temporarly force crypto with encfs settings.setCryptoParameters() if settings.cryptoPassword != "": mediaItems = service.getMediaList(folderID,contentType=8) if mediaItems: from resources.lib import encryption encrypt = encryption.encryption(settings.cryptoSalt,settings.cryptoPassword) if contentType == 9: mediaList = ['.mp4', '.flv', '.mov', '.webm', '.avi', '.ogg', '.mkv'] elif contentType == 10: mediaList = ['.mp3', '.flac'] else:# contentType == 11: mediaList = ['.jpg', '.png'] media_re = re.compile("|".join(mediaList), re.I) #create the files and folders for decrypting file/folder names for item in mediaItems: if item.file is None: try: item.folder.displaytitle = encrypt.decryptString(str(item.folder.title)) service.addDirectory(item.folder, contextType=contextType, encfs=True ) except: pass else: try: item.file.displaytitle = encrypt.decryptString(str(item.file.title)) item.file.title = item.file.displaytitle if contentType < 9 or media_re.search(str(item.file.title)): service.addMediaFile(item, contextType=contextType, encfs=True) except: pass else: settings.setEncfsParameters() encryptedPath = settings.getParameter('epath', '') dencryptedPath = settings.getParameter('dpath', '') encfs_source = settings.encfsSource encfs_target = settings.encfsTarget encfs_inode = settings.encfsInode mediaItems = service.getMediaList(folderID,contentType=8) if mediaItems: dirListINodes = {} fileListINodes = {} #create the files and folders for decrypting file/folder names for item in mediaItems: if item.file is None: xbmcvfs.mkdir(encfs_source + str(encryptedPath)) xbmcvfs.mkdir(encfs_source + str(encryptedPath) + str(item.folder.title) + '/' ) if encfs_inode == 0: dirListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath) + str(item.folder.title)).st_ino()))] = item.folder else: dirListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath) + str(item.folder.title)).st_ctime()))] = item.folder #service.addDirectory(item.folder, contextType=contextType, encfs=True) else: xbmcvfs.mkdir(encfs_source + str(encryptedPath)) xbmcvfs.mkdir(encfs_source + str(encryptedPath) + str(item.file.title)) if encfs_inode == 0: fileListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath)+ str(item.file.title)).st_ino()))] = item else: fileListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath) + str(item.file.title)).st_ctime()))] = item #service.addMediaFile(item, contextType=contextType) if encfs_inode > 0: xbmc.sleep(1000) if contentType == 9: mediaList = ['.mp4', '.flv', '.mov', '.webm', '.avi', '.ogg', '.mkv'] elif contentType == 10: mediaList = ['.mp3', '.flac'] else:# contentType == 11: mediaList = ['.jpg', '.png'] media_re = re.compile("|".join(mediaList), re.I) #examine the decrypted file/folder names for files for playback and dirs for navigation dirs, files = xbmcvfs.listdir(encfs_target + str(dencryptedPath) ) for dir in dirs: index = '' if encfs_inode == 0: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPath) + dir).st_ino()) else: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPath) + dir).st_ctime()) #we found a directory if index in dirListINodes.keys(): xbmcvfs.rmdir(encfs_target + str(dencryptedPath) + dir) # dirTitle = dir + ' [' +dirListINodes[index].title+ ']' encryptedDir = dirListINodes[index].title dirListINodes[index].displaytitle = dir + ' [' +dirListINodes[index].title+ ']' service.addDirectory(dirListINodes[index], contextType=contextType, encfs=True, dpath=str(dencryptedPath) + str(dir) + '/', epath=str(encryptedPath) + str(encryptedDir) + '/' ) #we found a file elif index in fileListINodes.keys(): xbmcvfs.rmdir(encfs_target + str(dencryptedPath) + dir) fileListINodes[index].file.decryptedTitle = dir if contentType < 9 or media_re.search(str(dir)): service.addMediaFile(fileListINodes[index], contextType=contextType, encfs=True, dpath=str(dencryptedPath) + str(dir), epath=str(encryptedPath) ) # file is already downloaded for file in files: index = '' if encfs_inode == 0: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPath) + file).st_ino()) else: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPath) + file).st_ctime()) if index in fileListINodes.keys(): fileListINodes[index].file.decryptedTitle = file if contentType < 9 or media_re.search(str(file)): service.addMediaFile(fileListINodes[index], contextType=contextType, encfs=True, dpath=str(dencryptedPath) + str(file), epath=str(encryptedPath) ) #xbmc.executebuiltin("XBMC.Container.Refresh") else: path = settings.getParameter('epath', '') # real folder if folderID != '': mediaItems = service.getMediaList(folderID,contentType=contentType) if addon_parameters.spreadsheet and service.cloudResume == '2': if service.gSpreadsheet is None: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) if service.worksheetID != '': service.gSpreadsheet.updateMediaPackageList(service.worksheetID, folderID, mediaItems) if mediaItems: for item in sorted(mediaItems): if item.file is None: service.addDirectory(item.folder, contextType=contextType, epath=str(path)+ '/' + str(item.folder.title) + '/') else: service.addMediaFile(item, contextType=contextType) # virtual folder; exists in spreadsheet only # not in use #elif folderName != '': service.updateAuthorization(addon) # NOT IN USE #** testing - gdrive elif mode == 'kiosk': spreadshetModule = settings.getSetting('library', False) if spreadshetModule: gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) service.gSpreadsheet = gSpreadsheet spreadsheets = service.getSpreadsheetList() channels = [] for title in spreadsheets.iterkeys(): if title == 'TVShows': worksheets = gSpreadsheet.getSpreadsheetWorksheets(spreadsheets[title]) if 0: import time hour = time.strftime("%H") minute = time.strftime("%M") weekDay = time.strftime("%w") month = time.strftime("%m") day = time.strftime("%d") for worksheet in worksheets.iterkeys(): if worksheet == 'schedule': channels = gSpreadsheet.getChannels(worksheets[worksheet]) ret = xbmcgui.Dialog().select(addon.getLocalizedString(30112), channels) shows = gSpreadsheet.getShows(worksheets[worksheet] ,channels[ret]) showList = [] for show in shows: showList.append(shows[show][6]) ret = xbmcgui.Dialog().select(addon.getLocalizedString(30112), showList) for worksheet in worksheets.iterkeys(): if worksheet == 'data': episodes = gSpreadsheet.getVideo(worksheets[worksheet] ,showList[ret]) #player = gPlayer.gPlayer() #player.setService(service) player.setContent(episodes) player.setWorksheet(worksheets['data']) player.next() while not player.isExit: xbmc.sleep(5000) else: for worksheet in worksheets.iterkeys(): if worksheet == 'db': episodes = gSpreadsheet.getMedia(worksheets[worksheet], service.getRootID()) #player = gPlayer.gPlayer() #player.setService(service) # player.setContent(episodes) player.setWorksheet(worksheets['db']) player.PlayStream('plugin://plugin.video.'+addon_parameters.PLUGIN_NAME+'-testing/?mode=video&instance='+str(service.instanceName)+'&title='+episodes[0][3], None,episodes[0][7],episodes[0][2]) #player.next() while not player.isExit: player.saveTime() xbmc.sleep(5000) ##** not in use elif mode == 'photo': title = settings.getParameter('title',0) title = re.sub('/', '_', title) #remap / from titles (google photos) docid = settings.getParameter('filename') folder = settings.getParameter('folder',0) encfs = settings.getParameter('encfs', False) if encfs: settings.setEncfsParameters() encryptedPath = settings.getParameter('epath', '') dencryptedPath = settings.getParameter('dpath', '') encfs_source = settings.encfsSource encfs_target = settings.encfsTarget encfs_inode = settings.encfsInode # don't redownload if present already if (not xbmcvfs.exists(str(encfs_source) + str(encryptedPath) +str(title))): url = service.getDownloadURL(docid) service.downloadGeneralFile(url, str(encfs_source) + str(encryptedPath) +str(title)) xbmc.executebuiltin("XBMC.ShowPicture(\""+str(encfs_target) + str(dencryptedPath)+"\")") #item = xbmcgui.ListItem(path=str(encfs_target) + str(dencryptedPath)) #xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) else: path = settings.getSetting('photo_folder') #workaround for this issue: https://github.com/xbmc/xbmc/pull/8531 if not xbmcvfs.exists(path) and not os.path.exists(path): path = '' while path == '': path = xbmcgui.Dialog().browse(0,addon.getLocalizedString(30038), 'files','',False,False,'') #workaround for this issue: https://github.com/xbmc/xbmc/pull/8531 if not xbmcvfs.exists(path) and not os.path.exists(path): path = '' else: addon.setSetting('photo_folder', path) if (not xbmcvfs.exists(str(path) + '/'+str(folder) + '/')): xbmcvfs.mkdir(str(path) + '/'+str(folder)) # try: # xbmcvfs.rmdir(str(path) + '/'+str(folder)+'/'+str(title)) # except: # pass # don't redownload if present already if (not xbmcvfs.exists(str(path) + '/'+str(folder)+'/'+str(title))): url = service.getDownloadURL(docid) service.downloadPicture(url, str(path) + '/'+str(folder) + '/'+str(title)) #xbmc.executebuiltin("XBMC.ShowPicture("+str(path) + '/'+str(folder) + '/'+str(title)+")") #item = xbmcgui.ListItem(path=str(path) + '/'+str(folder) + '/'+str(title)) url = service.getDownloadURL(docid) item = xbmcgui.ListItem(path=url + '|' + service.getHeadersEncoded()) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) elif mode == 'downloadfolder': title = settings.getParameter('title') folderID = settings.getParameter('folder') folderName = settings.getParameter('foldername') encfs = settings.getParameter('encfs', False) try: service except NameError: xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30051), addon.getLocalizedString(30052)) xbmc.log(addon.getLocalizedString(30050)+ addon_parameters.PLUGIN_NAME + '-login',xbmc.LOGERROR) xbmcplugin.endOfDirectory(plugin_handle) if encfs: settings.setEncfsParameters() encryptedPath = settings.getParameter('epath', '') dencryptedPath = settings.getParameter('dpath', '') encfs_source = settings.encfsSource encfs_target = settings.encfsTarget encfs_inode = settings.encfsInode else: path = settings.getParameter('epath', '/') if encfs: mediaItems = service.getMediaList(folderName=folderID, contentType=8) path = str(encfs_source) + str(encryptedPath) else: mediaItems = service.getMediaList(folderName=folderID, contentType=contentType) path = str(settings.getSetting('photo_folder')) + str(path) if mediaItems: progress = xbmcgui.DialogProgressBG() progressBar = len(mediaItems) progress.create(addon.getLocalizedString(30092), '') count=0 if not xbmcvfs.exists(path) and not os.path.exists(path): xbmcvfs.mkdirs(path) for item in mediaItems: count = count + 1 if item.file is not None: progress.update((int)(float(count)/len(mediaItems)*100),addon.getLocalizedString(30092), str(item.file.title)) service.downloadGeneralFile(item.getMediaURL(),str(path) + str(item.file.title) ) # elif item.folder is not None: # # create path if doesn't exist # if (not xbmcvfs.exists(str(path) + '/'+str(folder) + '/')): # xbmcvfs.mkdir(str(path) + '/'+str(folder)) progress.close() elif mode == 'slideshow': folder = settings.getParameter('folder',0) title = settings.getParameter('title',0) encfs = settings.getParameter('encfs', False) if encfs: settings.setEncfsParameters() encfs_source = settings.encfsSource encfs_target = settings.encfsTarget encfs_inode = settings.encfsInode if (not xbmcvfs.exists(str(encfs_target) + '/'+str(folder) + '/')): xbmcvfs.mkdir(str(encfs_target) + '/'+str(folder)) folderINode = '' if encfs_inode == 0: folderINode = str(xbmcvfs.Stat(encfs_target + '/' + str(folder)).st_ino()) else: folderINode = str(xbmcvfs.Stat(encfs_target + '/' + str(folder)).st_ctime()) mediaItems = service.getMediaList(folderName=folder, contentType=8) if mediaItems: dirs, filesx = xbmcvfs.listdir(encfs_source) for dir in dirs: index = '' if encfs_inode == 0: index = str(xbmcvfs.Stat(encfs_source + '/' + dir).st_ino()) else: index = str(xbmcvfs.Stat(encfs_source + '/' + dir).st_ctime()) if index == folderINode: progress = xbmcgui.DialogProgressBG() progress.create(addon.getLocalizedString(30035), 'Preparing list...') count=0 for item in mediaItems: if item.file is not None: count = count + 1; progress.update((int)(float(count)/len(mediaItems)*100),addon.getLocalizedString(30035), item.file.title) if (not xbmcvfs.exists(str(encfs_source) + '/'+str(dir)+'/'+str(item.file.title))): service.downloadGeneralFile(item.mediaurl.url,str(encfs_source) + '/'+str(dir)+ '/'+str(item.file.title)) if encfs_inode > 0: xbmc.sleep(100) progress.close() xbmc.executebuiltin("XBMC.SlideShow(\""+str(encfs_target) + '/'+str(folder)+"/\")") elif 0: path = settings.getSetting('photo_folder') #workaround for this issue: https://github.com/xbmc/xbmc/pull/8531 if not xbmcvfs.exists(path) and not os.path.exists(path): path = '' while path == '': path = xbmcgui.Dialog().browse(0,addon.getLocalizedString(30038), 'files','',False,False,'') #workaround for this issue: https://github.com/xbmc/xbmc/pull/8531 if not xbmcvfs.exists(path) and not os.path.exists(path): path = '' else: addon.setSetting('photo_folder', path) # create path if doesn't exist if (not xbmcvfs.exists(str(path) + '/'+str(folder) + '/')): xbmcvfs.mkdir(str(path) + '/'+str(folder)) mediaItems = service.getMediaList(folderName=folder, contentType=5) if mediaItems: progress = xbmcgui.DialogProgressBG() progress.create(addon.getLocalizedString(30035), 'Preparing list...') count=0 for item in mediaItems: if item.file is not None: count = count + 1; progress.update((int)(float(count)/len(mediaItems)*100),addon.getLocalizedString(30035), item.file.title) service.downloadGeneralFile(item.mediaurl.url,str(path) + '/'+str(folder)+ '/'+item.file.title) #xbmc.executebuiltin("XBMC.SlideShow("+str(path) + '/'+str(folder)+"/)") progress.close() xbmc.executebuiltin("XBMC.SlideShow(\""+str(path) + '/'+str(folder)+"/\")") #else: # xbmc.executebuiltin("XBMC.SlideShow("+str(path) + '/'+str(folder)+"/)") ### # for video files # force stream - play a video given its url ### elif mode == 'streamurl': url = settings.getParameter('url',0) title = settings.getParameter('title') promptQuality = settings.getSetting('prompt_quality', True) mediaURLs = service.getPublicStream(url) options = [] if mediaURLs: mediaURLs = sorted(mediaURLs) for mediaURL in mediaURLs: options.append(mediaURL.qualityDesc) if promptQuality: ret = xbmcgui.Dialog().select(addon.getLocalizedString(30033), options) else: ret = 0 playbackURL = mediaURLs[ret].url if (playbackURL == ''): xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30020),addon.getLocalizedString(30021)) xbmc.log(addon.getAddonInfo('name') + ': ' + addon.getLocalizedString(20021), xbmc.LOGERROR) else: # if invoked in .strm or as a direct-video (don't prompt for quality) item = xbmcgui.ListItem(path=playbackURL+ '|' + service.getHeadersEncoded()) item.setInfo( type="Video", infoLabels={ "Title": mediaURLs[ret].title , "Plot" : mediaURLs[ret].title } ) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) else: xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30020),addon.getLocalizedString(30021)) xbmc.log(addon.getAddonInfo('name') + ': ' + addon.getLocalizedString(20021), xbmc.LOGERROR) ### # for video files - playback of video # force stream - play a video given its url ### # # legacy (depreicated) - memorycachevideo [given title] # legacy (depreicated) - play [given title] # legacy (depreicated) - playvideo [given title] # legacy (depreicated) - streamvideo [given title] elif mode == 'audio' or mode == 'video' or mode == 'search' or mode == 'play' or mode == 'memorycachevideo' or mode == 'playvideo' or mode == 'streamvideo': title = settings.getParameter('title') #file title filename = settings.getParameter('filename') #file ID folderID = settings.getParameter('folder') #folder ID spreadsheetSTRM = settings.getParameter('spreadsheet') sheetSTRM = settings.getParameter('sheet') year = settings.getParameter('year') if sheetSTRM != None and sheetSTRM != '': if service.gSpreadsheet is None: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) try: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) spreadsheets = service.gSpreadsheet.getSpreadsheetList() except: pass spreadsheet = None for t in spreadsheets.iterkeys(): if t == 'Movies': worksheets = service.gSpreadsheet.getSpreadsheetWorksheets(spreadsheets[t]) for worksheet in worksheets.iterkeys(): if worksheet == 'db': spreadsheet = worksheets[worksheet] break break if spreadsheet != None: filename = service.gSpreadsheet.getSTRMplaybackMovie(spreadsheet, title, year) else: filename = service.gSpreadsheet.getSTRMplaybackMovie('https://spreadsheets.google.com/feeds/list/'+spreadsheetSTRM+'/'+sheetSTRM+'/private/full', title, year) if folderID == 'False': folderID = 'SEARCH' if mode != 'audio': settings.setVideoParameters() seek = 0 if settings.seek: dialog = xbmcgui.Dialog() seek = dialog.numeric(2, 'Time to seek to', '00:00') for r in re.finditer('(\d+)\:(\d+)' ,seek, re.DOTALL): seekHours, seekMins = r.groups() seek = int(seekMins) + (int(seekHours)*60) try: service except NameError: xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30051), addon.getLocalizedString(30052)) xbmc.log(addon.getLocalizedString(30050)+ addon_parameters.PLUGIN_NAME + '-login', xbmc.LOGERROR) xbmcplugin.endOfDirectory(plugin_handle) #settings.setCacheParameters() if mode == 'memorycachevideo': settings.play = True settings.download = True elif mode == 'playvideo': settings.play = False settings.download = False settings.playOriginal = True if settings.cache: settings.download = False settings.play = False encfs = settings.getParameter('encfs', False) #testing player = gPlayer.gPlayer() player.setService(service) resolvedPlayback = True startPlayback = False toExit = False #package = None if encfs: #temporarly force crypto with encfs settings.setCryptoParameters() if settings.cryptoPassword != "": mediaFile = file.file(filename, title, '', 0, '','') mediaFolder = folder.folder(folderID,'') (mediaURLs,package) = service.getPlaybackCall(package=package.package(mediaFile,mediaFolder), title=title, contentType=8) #override title package.file.title = title #(mediaURLs,package) = service.getPlaybackCall(None,title=title) mediaURL = mediaURLs[0] #mediaURL.url = mediaURL.url +'|' + service.getHeadersEncoded() #print "mediaURLDD = " + mediaURL.url # use streamer if defined useStreamer = False if service is not None and service.settings.streamer: # test streamer from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer from resources.lib import streamer import urllib, urllib2 from SocketServer import ThreadingMixIn import threading try: server = streamer.MyHTTPServer(('', service.settings.streamPort), streamer.myStreamer) server.setAccount(service, '') #if we make it here, streamer was not already running as a service, so we need to abort and playback using normal method, otherwise we will lock except: useStreamer = True if useStreamer: url = 'http://localhost:' + str(service.settings.streamPort) + '/crypto_playurl' req = urllib2.Request(url, 'url=' + mediaURL.url) print "mediaURL = "+mediaURL.url try: response = urllib2.urlopen(req) response.close() except urllib2.URLError, e: xbmc.log(self.addon.getAddonInfo('name') + ': ' + str(e), xbmc.LOGERROR) item = xbmcgui.ListItem(package.file.displayTitle(), iconImage=package.file.thumbnail, thumbnailImage=package.file.thumbnail, path='http://localhost:' + str(service.settings.streamPort) + '/play') item.setPath('http://localhost:' + str(service.settings.streamPort) + '/play') xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) ## contribution by dabinn # handle situation where playback is skipped to next file, wait for new source to load if player.isPlaying(): xbmc.sleep(100) startPlayback = False # need to seek? if seek > 0: player.PlayStream(mediaURL.url, item, seek, startPlayback=startPlayback, package=package) elif float(package.file.cloudResume) > 0: player.PlayStream(mediaURL.url, item, package.file.cloudResume, startPlayback=startPlayback, package=package) elif float(package.file.resume) > 0: player.PlayStream(mediaURL.url, item, package.file.resume, startPlayback=startPlayback, package=package) else: player.PlayStream(mediaURL.url, item, 0, startPlayback=startPlayback, package=package) # must occur after playback started (resolve or startPlayback in player) # load captions if 0 and (settings.srt or settings.cc) and (service.protocol == 2 or service.protocol == 3): while not (player.isPlaying()): xbmc.sleep(1000) files = cache.getSRT(service) for file in files: if file != '': try: #file = file.decode('unicode-escape') file = file.encode('utf-8') except: pass player.setSubtitles(file) xbmc.sleep(100) # we need to keep the plugin alive for as long as there is playback from the plugin, or the player object closes while not player.isExit: player.saveTime() xbmc.sleep(5000) else: settings.setEncfsParameters() encryptedPath = settings.getParameter('epath', '') dencryptedPath = settings.getParameter('dpath', '') encfs_source = settings.encfsSource encfs_target = settings.encfsTarget encfs_inode = settings.encfsInode mediaFile = file.file(filename, title, '', 0, '','') mediaFolder = folder.folder(folderID,'') (mediaURLs,package) = service.getPlaybackCall(package=package.package(mediaFile,mediaFolder), title=title, contentType=8) #(mediaURLs,package) = service.getPlaybackCall(None,title=title) mediaURL = mediaURLs[0] playbackTarget = encfs_target + dencryptedPath item = xbmcgui.ListItem(package.file.displayTitle(), iconImage=package.file.thumbnail, thumbnailImage=package.file.thumbnail, path=playbackTarget) #item.setInfo( type="Video", infoLabels={ "Title": package.file.title , "Plot" : package.file.title } ) # right-click or integrated player (no opening stream dialog...) if contextType == '': # for STRM (force resolve) -- resolve-only if settings.username != '': resolvedPlayback = True startPlayback = False else: startPlayback = True # resolve for an opening stream dialog else: resolvedPlayback=True # download if not already cached # if (not xbmcvfs.exists(str(encfs_source) + encryptedPath +str(title))): url = service.getDownloadURL(filename) ## check for SRT # use folderID, look for files with srt/sub mediaItems = service.getMediaList(folderID,contentType=8) encfsSubTitles = [] if mediaItems: dirListINodes = {} fileListINodes = {} #create the files and folders for decrypting file/folder names for itemx in mediaItems: if itemx.file is None: xbmcvfs.mkdir(encfs_source + str(encryptedPath)) xbmcvfs.mkdir(encfs_source + str(encryptedPath) + str(itemx.folder.title) + '/' ) if encfs_inode == 0: dirListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath) + str(itemx.folder.title)).st_ino()))] = itemx.folder else: dirListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath) + str(itemx.folder.title)).st_ctime()))] = itemx.folder #service.addDirectory(item.folder, contextType=contextType, encfs=True) else: xbmcvfs.mkdir(encfs_source + str(encryptedPath)) xbmcvfs.mkdir(encfs_source + str(encryptedPath) + str(itemx.file.title)) if encfs_inode == 0: fileListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath)+ str(itemx.file.title)).st_ino()))] = itemx else: fileListINodes[(str(xbmcvfs.Stat(encfs_source + str(encryptedPath) + str(itemx.file.title)).st_ctime()))] = itemx #service.addMediaFile(itemx, contextType=contextType) if encfs_inode > 0: xbmc.sleep(1000) mediaList = ['.sub', '.srt'] media_re = re.compile("|".join(mediaList), re.I) # encfs -- extract path extrapulatedPath = re.compile('(.*?)/[^/]+$') dencryptedPathWithoutFilename = extrapulatedPath.match(dencryptedPath) if dencryptedPathWithoutFilename is None: dencryptedPathWithoutFilename = '' else: dencryptedPathWithoutFilename = dencryptedPathWithoutFilename.group(1) + '/' #examine the decrypted file/folder names for files for playback and dirs for navigation dirs, files = xbmcvfs.listdir(encfs_target + str(dencryptedPathWithoutFilename) ) for dir in dirs: index = '' if encfs_inode == 0: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPathWithoutFilename) + dir).st_ino()) else: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPathWithoutFilename) + dir).st_ctime()) #we found a file if index in fileListINodes.keys(): xbmcvfs.rmdir(encfs_target + str(dencryptedPathWithoutFilename) + dir) fileListINodes[index].file.decryptedTitle = dir if media_re.search(str(dir)): #we found a subtitle service.downloadGeneralFile(fileListINodes[index].mediaurl.url, str(encfs_source) + str(encryptedPath) +str(fileListINodes[index].file.title)) # str(encfs_target) + str(dencryptedPathWithoutFilename) + str(fileListINodes[index].file.decryptedTitle) encfsSubTitles.append(str(encfs_target) + str(dencryptedPathWithoutFilename) + str(fileListINodes[index].file.decryptedTitle)) # file is already downloaded for file in files: index = '' if encfs_inode == 0: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPathWithoutFilename) + file).st_ino()) else: index = str(xbmcvfs.Stat(encfs_target + str(dencryptedPathWithoutFilename) + file).st_ctime()) if index in fileListINodes.keys(): fileListINodes[index].file.decryptedTitle = file if media_re.search(str(file)): #we found a subtitle # service.addMediaFile(fileListINodes[index], contextType=contextType, encfs=True, dpath=str(dencryptedPath) + str(file), epath=str(encryptedPath) ) # service.downloadGeneralFile(fileListINodes[index], package, playbackURL=playbackTarget, folderName=str(encfs_source) + encryptedPath + str(fileListINodes[index].file.title)) # service.downloadGeneralFile(fileListINodes[index].mediaurl.url, str(encfs_source) + str(encryptedPath) +str(title)) encfsSubTitles.append(str(encfs_target) + str(dencryptedPathWithoutFilename) + str(fileListINodes[index].file.decryptedTitle)) if settings.encfsStream or settings.encfsCacheSingle: ## calculate the decrypted name of the file cache.mp4 #creating a cache.mp4 file fileListINodes = {} #workaround for this issue: https://github.com/xbmc/xbmc/pull/8531 if not xbmcvfs.exists(encfs_target + 'encfs.mp4') and not os.path.exists(encfs_target + 'encfs.mp4'): xbmcvfs.mkdir(encfs_target + 'encfs.mp4') if encfs_inode == 0: fileListINodes[(str(xbmcvfs.Stat(encfs_target + 'encfs.mp4').st_ino()))] = item else: fileListINodes[(str(xbmcvfs.Stat(encfs_target + 'encfs.mp4').st_ctime()))] = item if encfs_inode > 0: xbmc.sleep(1000) dirs, files = xbmcvfs.listdir(encfs_source) for dir in dirs: index = '' if encfs_inode == 0: index = str(xbmcvfs.Stat(encfs_source + str(dir)).st_ino()) else: index = str(xbmcvfs.Stat(encfs_source + str(dir)).st_ctime()) #we found a file if index in fileListINodes.keys(): xbmcvfs.rmdir(encfs_source + str(dir)) addon.setSetting('encfs_last', str(encryptedPath) +str(title)) if settings.encfsExp: service.downloadEncfsFile2(mediaURL, package, playbackURL=encfs_target + 'encfs.mp4', folderName=str(encfs_source) + str(dir), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) else: service.downloadEncfsFile(mediaURL, package, playbackURL=encfs_target + 'encfs.mp4', folderName=str(encfs_source) + str(dir), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) #already downloaded (partial or full) for file in files: index = '' if encfs_inode == 0: index = str(xbmcvfs.Stat(encfs_source + str(file)).st_ino()) else: index = str(xbmcvfs.Stat(encfs_source + str(file)).st_ctime()) #we found a file if index in fileListINodes.keys(): #resume if settings.encfsLast == str(encryptedPath) +str(title): if settings.encfsExp: service.downloadEncfsFile2(mediaURL, package, playbackURL=encfs_target + 'encfs.mp4', force=False,folderName=str(encfs_source) + str(file), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) else: service.downloadEncfsFile(mediaURL, package, playbackURL=encfs_target + 'encfs.mp4', force=False,folderName=str(encfs_source) + str(file), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) #new file else: addon.setSetting('encfs_last', str(encryptedPath) +str(title)) if settings.encfsExp: service.downloadEncfsFile2(mediaURL, package, playbackURL=encfs_target + 'encfs.mp4', force=True, folderName=str(encfs_source) + str(file), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) else: service.downloadEncfsFile(mediaURL, package, playbackURL=encfs_target + 'encfs.mp4', force=True, folderName=str(encfs_source) + str(file), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) else: #service.downloadEncfsFile2(mediaURL, package, playbackURL=playbackTarget, folderName=str(encfs_source) + encryptedPath +str(title), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) service.downloadEncfsFile(mediaURL, package, playbackURL=playbackTarget, folderName=str(encfs_source) + encryptedPath +str(title), playback=resolvedPlayback,item=item, player=player, srt=encfsSubTitles) #should already be playing by this point, so don't restart it startPlayback = False #exists; resolve for an opening stream dialog # elif resolvedPlayback: # xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) # need to seek? #if seek > 0: # player.PlayStream(playbackTarget, item, seek, startPlayback=startPlayback, package=package) #elif float(package.file.resume) > 0: # player.PlayStream(playbackTarget, item, package.file.resume, startPlayback=startPlayback, package=package) #else: # player.PlayStream(playbackTarget, item, 0, startPlayback=startPlayback, package=package) #loop until finished while not player.isExit: player.saveTime() xbmc.sleep(5000) elif mode == 'search' and contextType != '': if title == '': try: dialog = xbmcgui.Dialog() title = dialog.input(addon.getLocalizedString(30110), type=xbmcgui.INPUT_ALPHANUM) except: xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30100)) title = 'test' mediaItems = service.getMediaList(title=title, contentType=contentType) resolvedPlayback = False startPlayback = False options = [] urls = [] if mediaItems: for item in mediaItems: if item.file is None: service.addDirectory( item.folder, contextType=contextType) else: service.addMediaFile(item, contextType=contextType) # non-encfs else: # file ID provided #if we don't have the docid, search for the video for playback if (filename != '' and mode == 'audio'): mediaFile = file.file(filename, title, '', service.MEDIA_TYPE_MUSIC, '','') mediaFolder = folder.folder(folderID,'') (mediaURLs,package) = service.getPlaybackCall(package=package.package(mediaFile,mediaFolder)) elif filename != '': mediaFile = file.file(filename, title, '', 0, '','') mediaFolder = folder.folder(folderID,'') (mediaURLs,package) = service.getPlaybackCall(package=package.package(mediaFile,mediaFolder)) # search elif mode == 'search' and contextType == '': if title == '': try: dialog = xbmcgui.Dialog() title = dialog.input(addon.getLocalizedString(30110), type=xbmcgui.INPUT_ALPHANUM) except: xbmcgui.Dialog().ok(addon.getLocalizedString(30000), addon.getLocalizedString(30100)) title = 'test' mediaItems = service.getMediaList(title=title, contentType=contentType) resolvedPlayback = False startPlayback = False options = [] urls = [] if mediaItems: for item in mediaItems: if item.file is None: service.addDirectory( item.folder, contextType=contextType) else: options.append(item.file.title) urls.append(service.addMediaFile(item, contextType=contextType)) #search from STRM if contextType == '': ret = xbmcgui.Dialog().select(addon.getLocalizedString(30112), options) playbackPath = urls[ret] item = xbmcgui.ListItem(path=playbackPath+'|' + service.getHeadersEncoded()) item.setInfo( type="Video", infoLabels={ "Title": options[ret] , "Plot" : options[ret] } ) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) # playback of entire folder? # folder only elif folderID != '' and title == '': mediaItems = service.getMediaList(folderName=folderID, contentType=contentType) if mediaItems: player.setMedia(mediaItems) player.playList(service) resolvedPlayback = False toExit = True # title provided else: (mediaURLs,package) = service.getPlaybackCall(None,title=title) #ensure there is something play if package is not None: # right-click - download (download only + force) if not seek > 0 and not (settings.download and not settings.play): # TESTING if addon_parameters.spreadsheet and service.cloudResume == '2': if service.worksheetID == '': try: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) spreadsheets = service.gSpreadsheet.getSpreadsheetList() except: pass for title in spreadsheets.iterkeys(): if title == 'CLOUD_DB': worksheets = service.gSpreadsheet.getSpreadsheetWorksheets(spreadsheets[title]) for worksheet in worksheets.iterkeys(): if worksheet == 'db': service.worksheetID = worksheets[worksheet] addon.setSetting(instanceName + '_spreadsheet', service.worksheetID) break break # TESTING if addon_parameters.spreadsheet and service.cloudResume == '2': if service.gSpreadsheet is None: service.gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) media = service.gSpreadsheet.updateMediaPackage(service.worksheetID, package) if package.file.commands != '': exp = re.compile('([^\|]+):([^\|]+)\|?', re.IGNORECASE) for cmd in exp.finditer(package.file.commands): if cmd.group(1) == 'seek': seek = cmd.group(2) elif cmd.group(1) == 'title': package.file.title = cmd.group(2) elif cmd.group(1) == 'resume': package.file.resume = cmd.group(2) elif cmd.group(1) == 'original': if cmd.group(2).lower() == 'true': settings.playOriginal = True else: settings.playOriginal = False elif cmd.group(1) == 'promptquality': if cmd.group(2).lower() == 'true': settings.promptQuality = True else: settings.promptQuality = False item = xbmcgui.ListItem(package.file.displayTitle(), iconImage=package.file.thumbnail, thumbnailImage=package.file.thumbnail) item.setInfo( type="Video", infoLabels={ "Title": package.file.title , "Plot" : package.file.title } ) originalURL = '' if mode != 'audio': cache = cache.cache(package) service.cache = cache package.file.thumbnail = cache.setThumbnail(service) # SRTURL = '' srtpath = '' if settings.srt and (service.protocol == 2 or service.protocol == 3): cache.setSRT(service) # download closed-captions if settings.cc and (service.protocol == 2 or service.protocol == 3): cache.setCC(service) mediaURL = service.getMediaSelection(mediaURLs, folderID, filename) #mediaURL.url = mediaURL.url +'|' + service.getHeadersEncoded() # if not seek > 0 and package.file.resume > 0 and not settings.cloudResumePrompt: # returnPrompt = xbmcgui.Dialog().yesno(addon.getLocalizedString(30000), addon.getLocalizedString(30176), str(int(float(package.file.resume)/360)) + ':'+ str(int(float(package.file.resume)/60)) + ':' + str(int(float(package.file.resume)%60))) # if not returnPrompt: # package.file.resume = 0 ### #right-menu context OR STRM ## if contextType == '': # right-click - download (download only + force) if not mediaURL.offline and settings.download and not settings.play: # service.downloadMediaFile('',playbackPath, str(title)+'.'+ str(playbackQuality), folderID, filename, fileSize, force=True) service.downloadMediaFile(mediaURL, item, package, force=True, playback=service.PLAYBACK_NONE) resolvedPlayback = False startPlayback = False # right-click - play + cache (download and play) elif not mediaURL.offline and settings.download and settings.play: # service.downloadMediaFile(int(sys.argv[1]), playbackPath, str(title)+'.'+ str(playbackQuality), folderID, filename, fileSize) service.downloadMediaFile(mediaURL, item, package, playback=service.PLAYBACK_PLAYER, player=player) resolvedPlayback = False # STRM (force resolve) -- resolve-only elif settings.username != '' or settings.strm: startPlayback = False resolvedPlayback = True if not seek > 0 and package.file.cloudResume > 0 and not settings.cloudResumePrompt: returnPrompt = xbmcgui.Dialog().yesno(addon.getLocalizedString(30000), addon.getLocalizedString(30176), str(int(float(package.file.cloudResume)/360)) + ':'+ str(int(float(package.file.cloudResume)/60)) + ':' + str(int(float(package.file.cloudResume)%60))) if not returnPrompt: package.file.resume = 0 else: package.file.resume = package.file.cloudResume item.setProperty('isResumable', '1') item.setProperty('ResumeTime', str(package.file.resume)) item.setProperty('TotalTime', str(package.file.duration)) # right-click - play original / SRT / CC / Start At elif settings.playOriginal or settings.srt or settings.cc or settings.seek: startPlayback = True resolvedPlayback = False #### not in use elif 0 and settings.resume: spreadshetModule = settings.getSetting('library', False) spreadshetName = settings.getSetting('library_filename', 'TVShows') media = {} if spreadshetModule: try: gSpreadsheet = gSpreadsheets.gSpreadsheets(service,addon, user_agent) service.gSpreadsheet = gSpreadsheet spreadsheets = gSpreadsheet.getSpreadsheetList() except: spreadshetModule = False if spreadshetModule: for title in spreadsheets.iterkeys(): if title == spreadshetName: worksheets = gSpreadsheet.getSpreadsheetWorksheets(spreadsheets[title]) for worksheet in worksheets.iterkeys(): if worksheet == 'db': media = gSpreadsheet.getMedia(worksheets[worksheet], fileID=package.file.id) item = xbmcgui.ListItem(package.file.displayTitle(), iconImage=package.file.thumbnail, thumbnailImage=package.file.thumbnail) item.setInfo( type="Video", infoLabels={ "Title": package.file.title , "Plot" : package.file.title } ) player.setWorksheet(worksheets['db']) if len(media) == 0: player.PlayStream(mediaURL.url, item, 0, package) else: player.PlayStream(mediaURL.url, item,media[0][7],package) while not player.isExit: player.saveTime() xbmc.sleep(5000) #offline elif mediaURL.offline: resolvedPlayback = True # left-click - always cache (download and play) elif not mediaURL.offline and settings.download and settings.play: service.downloadMediaFile(mediaURL, item, package, player=player) resolvedPlayback = False else: resolvedPlayback = True else: cache = cache.cache(package) service.cache = cache (localResolutions,localFiles) = service.cache.getFiles(service) if len(localFiles) > 0: mediaURL = mediaurl.mediaurl(str(localFiles[0]), 'offline', 0, 0) mediaURL.offline = True else: mediaURL = mediaURLs[0] if not settings.download: mediaURL.url = mediaURL.url +'|' + service.getHeadersEncoded() resolvedPlayback = True ### #right-menu context or STRM ## if contextType == '': #download - only, no playback if not mediaURL.offline and settings.download and not settings.play: service.downloadMediaFile(mediaURL, item, package, force=True, playback=service.PLAYBACK_NONE) resolvedPlayback = False # for STRM (force resolve) -- resolve-only elif settings.username != '': startPlayback = False #download & playback elif not mediaURL.offline and settings.download and settings.play: service.downloadMediaFile(mediaURL, item, package, playback=service.PLAYBACK_PLAYER, player=player) resolvedPlayback = False else: startPlayback = True # from within pictures mode, music won't be playable, force #direct playback from within plugin elif contextType == 'image' and settings.cache: item = xbmcgui.ListItem(path=str(playbackPath)) # local, not remote. "Music" is ok item.setInfo( type="Music", infoLabels={ "Title": title } ) player.play(mediaURL.url, item) resolvedPlayback = False # from within pictures mode, music won't be playable, force #direct playback from within plugin elif contextType == 'image': item = xbmcgui.ListItem(package.file.displayTitle(), iconImage=package.file.thumbnail, thumbnailImage=package.file.thumbnail, path=mediaURL.url) # for unknown reasons, for remote music, if Music is tagged as Music, it errors-out when playing back from "Music", doesn't happen when labeled "Video" item.setInfo( type="Video", infoLabels={ "Title": title } ) player.play(mediaURL.url, item) resolvedPlayback = False #download and play elif settings.download and settings.play: service.downloadMediaFile(mediaURL, item, package, player=player) resolvedPlayback = False if float(package.file.cloudResume) > 0 or float(package.file.resume) > 0: options = [] options.append('Resume from ' + str(int(float(package.file.resume))/60).zfill(2) +':' + str(int(float(package.file.resume))%60).zfill(2) ) options.append('Start from begining') ret = xbmcgui.Dialog().select(addon.getLocalizedString(30176), options) if ret == 1: package.file.resume = 0 if resolvedPlayback: # use streamer if defined # streamer useStreamer = False if service is not None and service.settings.streamer: # test streamer from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer from resources.lib import streamer import urllib, urllib2 from SocketServer import ThreadingMixIn import threading try: server = streamer.MyHTTPServer(('', service.settings.streamPort), streamer.myStreamer) server.setAccount(service, '') #if we make it here, streamer was not already running as a service, so we need to abort and playback using normal method, otherwise we will lock except: useStreamer = True if useStreamer and service is not None and service.settings.streamer: url = 'http://localhost:' + str(service.settings.streamPort) + '/playurl' req = urllib2.Request(url, 'url=' + mediaURL.url) try: response = urllib2.urlopen(req) response_data = response.read() response.close() except urllib2.URLError, e: xbmc.log(self.addon.getAddonInfo('name') + ': ' + str(e), xbmc.LOGERROR) item.setPath('http://localhost:' + str(service.settings.streamPort) + '/play') xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) else: # regular playback item.setPath(mediaURL.url) xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, item) ## contribution by dabinn # handle situation where playback is skipped to next file, wait for new source to load if player.isPlaying(): xbmc.sleep(100) # need to seek? if seek > 0: player.PlayStream(mediaURL.url, item, seek, startPlayback=startPlayback, package=package) elif float(package.file.cloudResume) > 0: player.PlayStream(mediaURL.url, item, package.file.cloudResume, startPlayback=startPlayback, package=package) elif float(package.file.resume) > 0: player.PlayStream(mediaURL.url, item, package.file.resume, startPlayback=startPlayback, package=package) else: player.PlayStream(mediaURL.url, item, 0, startPlayback=startPlayback, package=package) # must occur after playback started (resolve or startPlayback in player) # load captions if (settings.srt or settings.cc) and (service.protocol == 2 or service.protocol == 3): while not (player.isPlaying()): xbmc.sleep(1000) files = cache.getSRT(service) for file in files: if file != '': try: #file = file.decode('unicode-escape') file = file.encode('utf-8') except: pass player.setSubtitles(file) xbmc.sleep(100) # we need to keep the plugin alive for as long as there is playback from the plugin, or the player object closes while not player.isExit: player.saveTime() xbmc.sleep(5000) xbmcplugin.endOfDirectory(plugin_handle) # must load after all other (becomes blocking) # streamer if service is not None and service.settings.streamer: localTVDB = {} localMOVIEDB = {} #load data structure containing TV and Movies from KODI if (settings.getSetting('local_db')): result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}') for match in re.finditer('"episodeid":(\d+)\,"file"\:"([^\"]+)"', result):#, re.S): localTVDB[match.group(2)] = match.group(1) result = xbmc.executeJSONRPC('{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": { "sort": {"method":"lastplayed"}, "filter": {"field": "title", "operator": "isnot", "value":"1"}, "properties": [ "file"]}, "id": "1"}') for match in re.finditer('"file":"([^\"]+)","label":"[^\"]+","movieid":(\d+)', result):#, re.S): localMOVIEDB[match.group(1)] = match.group(2) from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer from resources.lib import streamer import urllib, urllib2 from SocketServer import ThreadingMixIn import threading try: server = streamer.MyHTTPServer(('', service.settings.streamPort), streamer.myStreamer) server.setAccount(service, '') if (settings.getSetting('local_db')): server.setTVDB(localTVDB) server.setTVDB(localMOVIEDB) print "ENABLED STREAMER \n\n\n" while server.ready: server.handle_request() server.socket.close() except: pass #automation - create strm files if 0 and service is not None and instanceName is not None and settings.strm: import time currentDate = time.strftime("%Y%m%d") if addon.getSetting(instanceName+'_changedate') == '' or int(addon.getSetting(instanceName+'_changedate')) < int(currentDate): try: path = settings.getSetting('strm_path') except: pass if path != '': try: pDialog = xbmcgui.DialogProgressBG() pDialog.create(addon.getLocalizedString(30000), 'Building STRMs...') except: pass #service = gdrive_api2.gdrive(PLUGIN_URL,addon,instanceName, user_agent, settings) try: addon.setSetting(instanceName + '_changedate', currentDate) service.buildSTRM2(path, contentType=contentType, pDialog=pDialog) except: pass try: pDialog.update(100) pDialog.close() except: pass # player = gPlayer.gPlayer() # player.play(playbackURL+'|' + service.getHeadersEncoded(), item) # while not (player.isPlaying()): # xbmc.sleep(1) # player.seekTime(1000) # w = tvWindow.tvWindow("tvWindow.xml",addon.getAddonInfo('path'),"Default") # w.setPlayer(player) # w.doModal() # player.seekTime(1000) # w = tvWindow.tvWindow("tvWindow.xml",addon.getAddonInfo('path'),"Default") # w.setPlayer(player) # w.doModal() # xbmc.executebuiltin("XBMC.PlayMedia("+str(playbackPath)+'|' + service.getHeadersEncoded()+")") #media = gSpreadsheet.setMediaStatus(worksheets[worksheet], package, watched=2, resume=2) #item = xbmcgui.ListItem(package.file.displayTitle(), iconImage=package.file.thumbnail, # thumbnailImage=package.file.thumbnail) #item.setInfo( type="Video", infoLabels={ "Title": package.file.title , "Plot" : package.file.title } ) #player = gPlayer.gPlayer() #player.setService(service) #player.setWorksheet(worksheets['db']) #if len(media) == 0: # player.PlayStream(mediaURL.url, item, 0, package) #else: # player.PlayStream(mediaURL.url, item,media[0][7],package) #while not player.isExit: # player.saveTime() # xbmc.sleep(5000)

gpl-2.0

Azure/azure-sdk-for-python

sdk/serialconsole/azure-mgmt-serialconsole/azure/mgmt/serialconsole/_microsoft_serial_console_client.py

1

4023

# 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 typing import TYPE_CHECKING from azure.mgmt.core import ARMPipelineClient from msrest import Deserializer, Serializer if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports from typing import Any, Optional from azure.core.credentials import TokenCredential from azure.core.pipeline.transport import HttpRequest, HttpResponse from ._configuration import MicrosoftSerialConsoleClientConfiguration from .operations import MicrosoftSerialConsoleClientOperationsMixin from .operations import SerialPortsOperations from . import models class MicrosoftSerialConsoleClient(MicrosoftSerialConsoleClientOperationsMixin): """The Azure Serial Console allows you to access the serial console of a Virtual Machine or VM scale set instance. :ivar serial_ports: SerialPortsOperations operations :vartype serial_ports: azure.mgmt.serialconsole.operations.SerialPortsOperations :param credential: Credential needed for the client to connect to Azure. :type credential: ~azure.core.credentials.TokenCredential :param subscription_id: Subscription ID which uniquely identifies the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call requiring it. :type subscription_id: str :param str base_url: Service URL """ def __init__( self, credential, # type: "TokenCredential" subscription_id, # type: str base_url=None, # type: Optional[str] **kwargs # type: Any ): # type: (...) -> None if not base_url: base_url = 'https://management.azure.com' self._config = MicrosoftSerialConsoleClientConfiguration(credential, 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._serialize.client_side_validation = False self._deserialize = Deserializer(client_models) self.serial_ports = SerialPortsOperations( self._client, self._config, self._serialize, self._deserialize) def _send_request(self, http_request, **kwargs): # type: (HttpRequest, Any) -> HttpResponse """Runs the network request through the client's chained policies. :param http_request: The network request you want to make. Required. :type http_request: ~azure.core.pipeline.transport.HttpRequest :keyword bool stream: Whether the response payload will be streamed. Defaults to True. :return: The response of your network call. Does not do error handling on your response. :rtype: ~azure.core.pipeline.transport.HttpResponse """ path_format_arguments = { 'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'), } http_request.url = self._client.format_url(http_request.url, **path_format_arguments) stream = kwargs.pop("stream", True) pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs) return pipeline_response.http_response def close(self): # type: () -> None self._client.close() def __enter__(self): # type: () -> MicrosoftSerialConsoleClient self._client.__enter__() return self def __exit__(self, *exc_details): # type: (Any) -> None self._client.__exit__(*exc_details)

mit

RedTea/gaedav

pyxml/dom/html/HTMLImageElement.py

4

3892

######################################################################## # # File Name: HTMLImageElement # # ### This file is automatically generated by GenerateHtml.py. ### DO NOT EDIT! """ WWW: http://4suite.com/4DOM e-mail: support@4suite.com Copyright (c) 2000 Fourthought Inc, USA. All Rights Reserved. See http://4suite.com/COPYRIGHT for license and copyright information """ import string from pyxml.dom import Node from pyxml.dom.html.HTMLElement import HTMLElement class HTMLImageElement(HTMLElement): def __init__(self, ownerDocument, nodeName="IMG"): HTMLElement.__init__(self, ownerDocument, nodeName) ### Attribute Methods ### def _get_lowSrc(self): return self.getAttribute("LOWSRC") def _set_lowSrc(self, value): self.setAttribute("LOWSRC", value) def _get_name(self): return self.getAttribute("NAME") def _set_name(self, value): self.setAttribute("NAME", value) def _get_align(self): return string.capitalize(self.getAttribute("ALIGN")) def _set_align(self, value): self.setAttribute("ALIGN", value) def _get_alt(self): return self.getAttribute("ALT") def _set_alt(self, value): self.setAttribute("ALT", value) def _get_border(self): return self.getAttribute("BORDER") def _set_border(self, value): self.setAttribute("BORDER", value) def _get_height(self): return self.getAttribute("HEIGHT") def _set_height(self, value): self.setAttribute("HEIGHT", value) def _get_hspace(self): return self.getAttribute("HSPACE") def _set_hspace(self, value): self.setAttribute("HSPACE", value) def _get_isMap(self): return self.hasAttribute("ISMAP") def _set_isMap(self, value): if value: self.setAttribute("ISMAP", "ISMAP") else: self.removeAttribute("ISMAP") def _get_longDesc(self): return self.getAttribute("LONGDESC") def _set_longDesc(self, value): self.setAttribute("LONGDESC", value) def _get_src(self): return self.getAttribute("SRC") def _set_src(self, value): self.setAttribute("SRC", value) def _get_useMap(self): return self.getAttribute("USEMAP") def _set_useMap(self, value): self.setAttribute("USEMAP", value) def _get_vspace(self): return self.getAttribute("VSPACE") def _set_vspace(self, value): self.setAttribute("VSPACE", value) def _get_width(self): return self.getAttribute("WIDTH") def _set_width(self, value): self.setAttribute("WIDTH", value) ### Attribute Access Mappings ### _readComputedAttrs = HTMLElement._readComputedAttrs.copy() _readComputedAttrs.update({ "lowSrc" : _get_lowSrc, "name" : _get_name, "align" : _get_align, "alt" : _get_alt, "border" : _get_border, "height" : _get_height, "hspace" : _get_hspace, "isMap" : _get_isMap, "longDesc" : _get_longDesc, "src" : _get_src, "useMap" : _get_useMap, "vspace" : _get_vspace, "width" : _get_width }) _writeComputedAttrs = HTMLElement._writeComputedAttrs.copy() _writeComputedAttrs.update({ "lowSrc" : _set_lowSrc, "name" : _set_name, "align" : _set_align, "alt" : _set_alt, "border" : _set_border, "height" : _set_height, "hspace" : _set_hspace, "isMap" : _set_isMap, "longDesc" : _set_longDesc, "src" : _set_src, "useMap" : _set_useMap, "vspace" : _set_vspace, "width" : _set_width }) _readOnlyAttrs = filter(lambda k,m=_writeComputedAttrs: not m.has_key(k), HTMLElement._readOnlyAttrs + _readComputedAttrs.keys())

lgpl-2.1

BorgERP/borg-erp-6of3

addons/point_of_sale/wizard/pos_payment.py

1

4106

# -*- coding: utf-8 -*- ############################################################################## # # OpenERP, Open Source Management Solution # Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>). # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # This program 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 Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # ############################################################################## import time from osv import osv, fields from tools.translate import _ import pos_box_entries import netsvc class pos_make_payment(osv.osv_memory): _name = 'pos.make.payment' _description = 'Point of Sale Payment' def check(self, cr, uid, ids, context=None): """Check the order: if the order is not paid: continue payment, if the order is paid print ticket. """ context = context or {} order_obj = self.pool.get('pos.order') obj_partner = self.pool.get('res.partner') active_id = context and context.get('active_id', False) order = order_obj.browse(cr, uid, active_id, context=context) amount = order.amount_total - order.amount_paid data = self.read(cr, uid, ids, context=context)[0] # this is probably a problem of osv_memory as it's not compatible with normal OSV's #data['journal'] = data['journal'][0] if amount != 0.0: order_obj.add_payment(cr, uid, active_id, data, context=context) if order_obj.test_paid(cr, uid, [active_id]): wf_service = netsvc.LocalService("workflow") wf_service.trg_validate(uid, 'pos.order', active_id, 'paid', cr) return self.print_report(cr, uid, ids, context=context) return self.launch_payment(cr, uid, ids, context=context) def launch_payment(self, cr, uid, ids, context=None): return { 'name': _('Payment'), 'view_type': 'form', 'view_mode': 'form', 'res_model': 'pos.make.payment', 'view_id': False, 'target': 'new', 'views': False, 'type': 'ir.actions.act_window', } def print_report(self, cr, uid, ids, context=None): active_id = context.get('active_id', []) datas = {'ids' : [active_id]} return { 'type': 'ir.actions.report.xml', 'report_name': 'pos.receipt', 'datas': datas, 'context': context, } def _default_journal(self, cr, uid, context=None): res = pos_box_entries.get_journal(self, cr, uid, context=context) return len(res)>1 and res[1][0] or False def _default_amount(self, cr, uid, context=None): order_obj = self.pool.get('pos.order') active_id = context and context.get('active_id', False) if active_id: order = order_obj.browse(cr, uid, active_id, context=context) return order.amount_total - order.amount_paid return False _columns = { 'journal': fields.selection(pos_box_entries.get_journal, "Payment Mode", required=True), 'amount': fields.float('Amount', digits=(16,2), required= True), 'payment_name': fields.char('Payment Reference', size=32), 'payment_date': fields.date('Payment Date', required=True), } _defaults = { 'payment_date': time.strftime('%Y-%m-%d %H:%M:%S'), 'amount': _default_amount, 'journal': _default_journal } pos_make_payment() # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

agpl-3.0

flarno11/teslarent

teslarent/manage_views.py

1

8703

import base64 import logging import uuid import datetime from json import encoder from django.conf import settings from django.contrib import admin from django.contrib.admin.views.decorators import staff_member_required from django.http import HttpResponse, HttpResponseForbidden from django.http.response import Http404, JsonResponse from django.shortcuts import redirect, render from jsonview.decorators import json_view from teslarent.forms import CredentialsForm, RentalForm from teslarent.management.commands.rental_start_end import BackgroundTask from teslarent.models import * from teslarent.teslaapi import teslaapi encoder.FLOAT_REPR = lambda o: format(o, '.2f') # monkey patching https://stackoverflow.com/questions/1447287/format-floats-with-standard-json-module log = logging.getLogger('manage') @json_view def ping(request): t = BackgroundTask.Instance() t.ensure_thread_running() return JsonResponse({'initialized_at': t.initialized_at}) def each_context(request, title="Title"): return { 'title': title, 'site_title': "Tesla Rental Admin", 'site_header': "Tesla Rental Admin", 'has_permission': admin.site.has_permission(request), } def check_basic_auth(request): if 'HTTP_AUTHORIZATION' in request.META: auth = request.META['HTTP_AUTHORIZATION'].split() if len(auth) == 2 and auth[0].lower() == "basic": return base64.b64decode(auth[1]).decode('utf-8').split(':') return None, None def metrics(request): if settings.METRICS_SECRET: username, password = check_basic_auth(request) if not username or not password or password != settings.METRICS_SECRET: return HttpResponseForbidden() content = [] for vehicle in Vehicle.objects.all(): content.append('vehicle{{id="{}", vehicle_id="{}", mobile_enabled="{}"}} 1'.format(vehicle.tesla_id, vehicle.vehicle_id, int(vehicle.mobile_enabled is True))) latest_vehicle_data_any = VehicleData.objects.filter(vehicle=vehicle).order_by('-created_at').first() if not latest_vehicle_data_any: continue latest_vehicle_data_online = VehicleData.objects.filter(vehicle=vehicle).filter(data__state='online').order_by('-created_at').first() content.append('vehicle_updated_at{vehicle="' + str(vehicle.vehicle_id) + '"} ' + str(latest_vehicle_data_any.created_at.timestamp())) content.append('vehicle_offline{vehicle="' + str(vehicle.vehicle_id) + '"} ' + ('1' if latest_vehicle_data_any.is_offline else '0')) if latest_vehicle_data_online: content.append('vehicle_last_online_at{vehicle="' + str(vehicle.vehicle_id) + '"} ' + str(latest_vehicle_data_online.created_at.timestamp())) latest_vehicle_data_locked = VehicleData.objects.filter(vehicle=vehicle).filter(data__vehicle_state__locked=True).order_by('-created_at').first() latest_vehicle_data_unlocked = VehicleData.objects.filter(vehicle=vehicle).filter(data__vehicle_state__locked=False).order_by('-created_at').first() if latest_vehicle_data_locked and latest_vehicle_data_unlocked: if latest_vehicle_data_unlocked.created_at > latest_vehicle_data_locked.created_at: content.append('vehicle_locked{vehicle="' + str(vehicle.vehicle_id) + '"} ' + str(latest_vehicle_data_locked.created_at.timestamp())) else: content.append('vehicle_locked{vehicle="' + str(vehicle.vehicle_id) + '"} ' + str(timezone.now().timestamp())) for credential in Credentials.objects.all(): content.append('token_expires_at{id="' + str(credential.email) + '"} ' + str(credential.token_expires_at.timestamp())) t = BackgroundTask.Instance() t.ensure_thread_running() content.append('background_task_initialized_at ' + str(t.initialized_at.timestamp())) content.append('') return HttpResponse("\n".join(content), content_type='text/plain') def sum_non_null(func, iterable): return sum(filter(None, map(func, iterable))) @staff_member_required def index(request): now = timezone.now() one_day_ago = now - datetime.timedelta(days=1) one_day_from_now = now + datetime.timedelta(days=1) rentals = Rental.objects.all().order_by('start') earnings_total_price_netto = 0 earnings_total_price_charging = 0 earnings_total_distance_driven = 0 for r in rentals: if r.price_netto and r.distance_driven: # only sum up if a price and distance is set earnings_total_price_netto += r.price_netto if r.price_charging: earnings_total_price_netto -= r.price_charging earnings_total_price_charging += r.price_charging earnings_total_distance_driven += r.distance_driven totals = { 'distance_driven_all': sum_non_null(lambda r: r.distance_driven, rentals), 'distance_driven_paid': earnings_total_distance_driven, 'price_brutto': sum_non_null(lambda r: r.price_brutto, rentals), 'price_netto': sum_non_null(lambda r: r.price_netto, rentals), 'price_charging_all': round(sum_non_null(lambda r: r.price_charging, rentals), 2), 'price_charging_paid': round(earnings_total_price_charging, 2), 'earnings_per_km': round(earnings_total_price_netto/earnings_total_distance_driven, 2), } vehicles = Vehicle.objects.all() for vehicle in vehicles: vehicle.d = VehicleData.objects.filter(vehicle=vehicle)\ .filter(data__charge_state__battery_level__isnull=False)\ .order_by('-created_at').first() context = dict( each_context(request, title="Manage Rentals"), debug=bool(settings.DEBUG), active_rentals=Rental.objects.filter(start__lt=one_day_from_now, end__gt=one_day_ago).order_by('start'), rentals=rentals, totals=totals, credentials=Credentials.objects.all(), vehicles=vehicles, has_any_vehicle=len(vehicles) > 0, has_active_vehicle=any([v.is_active for v in vehicles]), ) return render(request, 'manage.html', context) @staff_member_required def add_credentials(request): if request.method == "POST": form = CredentialsForm(request.POST) if form.is_valid(): email = form.cleaned_data['email'] c = Credentials.objects.filter(email=email).first() if not c: c = Credentials(email=email) teslaapi.login_and_save_credentials(c, form.cleaned_data['password']) del form.cleaned_data['password'] teslaapi.load_vehicles(c) return redirect('./') else: form = CredentialsForm() context = dict( each_context(request, title="Add Credentials"), form=form, ) return render(request, 'add_credentials.html', context) @staff_member_required def delete_credentials(request, credentials_id): c = Credentials.objects.get(id=credentials_id) if request.method == "POST": c.delete() return redirect('/manage/') context = dict( each_context(request, title="Delete Credentials"), credentials=c, ) return render(request, 'delete_credentials.html', context) @staff_member_required def add_rental(request): vehicles = Vehicle.get_all_active_vehicles() if len(vehicles) == 0: # TODO show error message to user log.warning("Cannot add rental, there is no active vehicle") return redirect('/manage/') vehicle = vehicles[0] if len(vehicles) == 1 else None start = timezone.now().replace(minute=0, second=0, microsecond=0) + datetime.timedelta(hours=1) end = start + datetime.timedelta(days=1) initial = Rental(start=start, end=end, vehicle=vehicle, code=str(uuid.uuid4())) return add_or_edit_rental(request, rental=initial) @staff_member_required def edit_rental(request, rental_id): return add_or_edit_rental(request, rental=Rental.objects.get(id=rental_id)) @staff_member_required def delete_rental(request, rental_id): r = Rental.objects.get(id=rental_id) if request.method == "POST": r.delete() BackgroundTask.Instance().ensure_thread_running() return redirect('/manage/') def add_or_edit_rental(request, rental): form = RentalForm(request.POST or None, instance=rental) if request.method == "POST": if form.is_valid(): form.save() BackgroundTask.Instance().ensure_thread_running() return redirect('/manage/') context = dict( each_context(request, title="Add/edit Rental"), form=form, ) return render(request, 'edit_rental.html', context)

apache-2.0

JoaquimPatriarca/senpy-for-gis

gasp/pgsql/q/time.py

1

7149

""" Analyse time references in PGTABLES """ def ID_rows_with_temporal_proximity_by_entities(conParam, table, entity_field, day_field, hour_field, hour_decimal_field, time_tolerance, outXlsPath): """ Retrieve rows from one pgtable with some temporal proximity Table structure should be entity | day | hour | hour_decimal 0 | 2018-01-02 | 5 | 5,10 0 | 2018-01-03 | 4 | 4,15 0 | 2018-01-02 | 5 | 5,12 0 | 2018-01-02 | 5 | 5,8 1 | 2018-01-02 | 4 | 4,10 1 | 2018-01-02 | 5 | 5,12 1 | 2018-01-02 | 4 | 4,20 1 | 2018-01-02 | 4 | 4,12 1 | 2018-01-02 | 4 | 4,6 For a time_tolerance of 5 minutes, the output table will have the rows with a temporal difference inside/bellow that time tolerance entity_field could be more than one field This method only identifies if one entity, for one day, has rows very close of each others, in terms of time. Not a good strategy for large tables. For large tables, SQL based methods are needed """ import pandas from gasp import goToList from gasp.frompsql import sql_query from gasp.pgsql.fields import get_columns_type from gasp.toxls import df_to_xls entity_field = goToList(entity_field) COLS = entity_field + [day_field, hour_field] COLS_TYPE = get_columns_type(conParam, table) # TIME TOLERANCE IN HOURS TIME_TOLERANCE = time_tolerance / 60.0 def thereIsRowsSameTimeInt(row): whr = [] for c in COLS: if COLS_TYPE[c] == str: whr.append("{}='{}'".format(c, row[c])) else: whr.append("{}={}".format(c, row[c])) hourRows = sql_query(conParam, "SELECT {} FROM {} WHERE {}".format( hour_decimal_field, table, " AND ".join(whr) ) ) for i in range(len(hourRows)): for e in range(i+1, len(hourRows)): dif = abs(hourRows[i][0] - hourRows[e][0]) if dif < TIME_TOLERANCE: break if dif < TIME_TOLERANCE: break if dif < TIME_TOLERANCE: row['time_difference'] = 1 else: row['time_difference'] = 0 return row # Count entity occourrences for one day and hour countsByEntityTime = pandas.DataFrame(sql_query( conParam, ("SELECT {scols}, conta FROM " "(SELECT {scols}, COUNT({ent}) AS conta FROM {tbl} " "GROUP BY {scols}) AS foo WHERE conta > 1").format( scols = ', '.join(COLS), ent = entity_field[0], tbl = table ) ), columns=COLS + ['conta']) # For each row in the last count, When count is > 1 # Check time difference between rows for one day and hour countsByEntityTime = countsByEntityTime.apply( lambda x: thereIsRowsSameTimeInt(x), axis=1 ) df_to_xls(countsByEntityTime, outXlsPath) return outXlsPath def del_rows_by_temporal_proximity(conpsql, table, entity_fields, day_field, hour_field, hour_decimal, minute_field, second_field, time_tolerance, outresult, exclusionRows=None): """ Exclude rows from one pgtable within some temporal interval from the previous row. Table structure should be entity | day | hour | minute | seconds | hour_decimal 0 | 2018-01-02 | 5 | X | X | 5,10 0 | 2018-01-03 | 4 | X | X | 4,15 0 | 2018-01-02 | 5 | X | X | 5,12 0 | 2018-01-02 | 5 | X | X | 5,8 1 | 2018-01-02 | 4 | X | X | 4,10 1 | 2018-01-02 | 5 | X | X | 5,12 1 | 2018-01-02 | 4 | X | X | 4,20 1 | 2018-01-02 | 4 | X | X | 4,12 1 | 2018-01-02 | 4 | X | X | 4,6 """ from gasp import goToList from gasp.pgsql.tables.w import create_table_by_query from gasp.pgsql.fields import get_columns_name entity_fields = goToList(entity_fields) if not entity_fields: raise ValueError("entity_fields value is not valid!") if exclusionRows: # Get Rows deleted in table sql = ( "SELECT *, ({hourDec} - previous_hour) AS deltatime FROM (" "SELECT *, {lag_entity}, " "LAG({hourDec}) OVER(PARTITION BY " "{entityCols}, {dayF} ORDER BY " "{entityCols}, {dayF}, {hourF}, {minutesF}, {secondsF}" ") AS previous_hour " "FROM {mtable} ORDER BY {entityCols}, {dayF}, " "{hourF}, {minutesF}, {secondsF}" ") AS w_previous_tbl " "WHERE previous_hour IS NOT NULL AND " "({hourDec} - previous_hour) < {tol} / 60.0" ).format( hourDec=hour_decimal, lag_entity = ", ".join([ "LAG({cl}) OVER(PARTITION BY {ent}, {d} ORDER BY {ent}, {d}, {h}, {m}, {s}) AS prev_{cl}".format( cl=c, ent=", ".join(entity_fields), d=day_field, h=hour_field, m=minute_field, s=second_field ) for c in entity_fields]), entityCols=", ".join(entity_fields), dayF=day_field, hourF=hour_field, minutesF=minute_field, secondsF=second_field, mtable=table, tol=str(time_tolerance) ) create_table_by_query(conpsql, exclusionRows, sql) # Get rows outside the given time tolerance sql = ( "SELECT *, ({hourDec} - previous_hour) AS deltatime FROM (" "SELECT *, {lag_entity}, " "LAG({hourDec}) OVER(PARTITION BY {entityCols}, {dayF} ORDER BY " "{entityCols}, {dayF}, {hourF}, {minutesF}, " "{secondsF}) AS previous_hour " "FROM {mtable} ORDER BY {entityCols}, {dayF}, {hourF}, " "{minutesF}, {secondsF}" ") AS w_previous_tbl " "WHERE ({hourDec} - previous_hour) IS NULL OR " "({hourDec} - previous_hour) > {tol} / 60.0" ).format( hourDec=hour_decimal, lag_entity=", ".join([ "LAG({cl}) OVER(PARTITION BY {ent}, {d} ORDER BY {ent}, {d}, {h}, {m}, {s}) AS prev_{cl}".format( cl=c, ent=", ".join(entity_fields), d=day_field, h=hour_field, m=minute_field, s=second_field ) for c in entity_fields]), entityCols=", ".join(entity_fields), dayF=day_field, hourF=hour_field, minutesF=minute_field, secondsF=second_field, mtable=table, tol=str(time_tolerance) ) create_table_by_query(conpsql, outresult, sql)

gpl-3.0

allanderek/drunken-octo-avenger

app/sgftools.py

2

3309

import re class ParseError(Exception): pass class SgfTree(object): # at the moment just a wrapper around 'nodes', a list of # dictionaries representing SGF tags. This wrapper exists in case # we want to add sub-trees, navigation methods etc. later, in # which case I suggest following the general shape of the objects # used by the Javascript library at # https://github.com/neagle/smartgame def __init__(self, nodes=None): if nodes is None: nodes = [] self.nodes = nodes self.main_line = nodes def generate(sgf_tree): nodes = sgf_tree.nodes if nodes == []: nodes = [{}] sgf = '(' for node in nodes: sgf += ';' for tag, values in node.items(): if not values: continue sgf += tag for value in values: sgf += '[' + value + ']' sgf += ')' return sgf def parse(sgf): d = {} d['rest'] = sgf def accept(char): return accept_re('\\' + char) def accept_re(pattern): """If pattern matches at current point in input, advance and return. If the pattern contains a group, return the content of the group. Otherwise, return the entire match. Either way, advance the current point over the entire match. If pattern does not match, do nothing and return None. """ regexp = re.compile(pattern) match = regexp.match(d['rest']) if match: whole = match.group() groups = match.groups() if len(groups) > 0: result = groups[0] else: result = whole d['rest'] = d['rest'][len(whole):] return result else: return None def expect(char): if not accept(char): raise ParseError("expected '{}' at '|' sign in '{}|{}'".format( char, sgf[:len(sgf)-len(d['rest'])], d['rest'])) def accept_whitespace(): accept_re(r"[ \t\n]*") def sequence(): expect('(') nodes_ = nodes() expect(')') return SgfTree(nodes_) def nodes(): result = [] accept_whitespace() while accept(';'): result.append(node_body()) accept_whitespace() return result def node_body(): result = {} while True: tag = accept_re(r"[A-Z]+") if not tag: break values = tag_values() result[tag] = values accept_whitespace() return result def tag_values(): result = [] while True: value = accept_re(r"\[([^]]*)\]") if value is None: break result.append(value) return result result = sequence() if result.nodes == [{}]: return SgfTree([]) else: return result _ord_a = ord('a') def encode_coord(x, y): return "{}{}".format(chr(x + _ord_a), chr(y + _ord_a)) def decode_coord(chars): try: x = ord(chars[0]) - _ord_a y = ord(chars[1]) - _ord_a except IndexError: raise ValueError("not enough digits in encoded coord: '{}'".format( chars)) return x, y

cc0-1.0

mjg/PyX-svn

test/functional/test_axis.py

1

3080

#!/usr/bin/env python import sys; sys.path[:0] = ["../.."] import math from pyx import * from pyx.graph.axis.parter import linear as linparter from pyx.graph.axis.painter import regular, ticklength, rotatetext from pyx.graph.axis.texter import rational, default from pyx.graph.axis.axis import lin, pathaxis c = canvas.canvas() lintest = {"title": "axis title", "min": 0, "max": 1, "parter": linparter(["0.25", "0.1/0.8"])} c.insert(pathaxis(path.path(path.moveto(0, 0), path.lineto(0, 8)), lin(**lintest), direction=-1)) c.insert(pathaxis(path.path(path.moveto(1, 0), path.lineto(1, 8)), lin(**lintest))) c.insert(pathaxis(path.path(path.moveto(5, 0), path.lineto(5, 8)), lin(painter=regular(labelattrs=[trafo.rotate(45)], titleattrs=[trafo.rotate(45)]), **lintest), direction=-1)) c.insert(pathaxis(path.path(path.moveto(8, 0), path.lineto(8, 8)), lin(painter=regular(labelattrs=[trafo.rotate(45), text.halign.right], titleattrs=[trafo.rotate(-45)]), **lintest), direction=-1)) c.insert(pathaxis(path.path(path.moveto(11, 0), path.lineto(11, 8)), lin(painter=regular(tickattrs=[color.rgb.red], innerticklength=0, outerticklength=ticklength.normal), **lintest), direction=-1)) c.insert(pathaxis(path.path(path.moveto(12, 0), path.lineto(12, 8)), lin(painter=regular(tickattrs=[attr.changelist([None, color.rgb.green])]), **lintest))) c.insert(pathaxis(path.path(path.moveto(16, 0), path.lineto(16, 8)), lin(texter=default(), **lintest), direction=-1)) c.insert(pathaxis(path.path(path.moveto(18, 0), path.lineto(18, 8)), lin(texter=rational(), **lintest), direction=-1)) lintest = {"title": "axis title", "min": -2*math.pi, "max": 0, "divisor": math.pi, "parter": linparter(["0.25"])} c.insert(pathaxis(path.path(path.moveto(0, 11), path.lineto(8, 11)), lin(texter=rational(suffix="\pi"), **lintest))) lintest = {"title": "axis title", "min": 0, "max": 2*math.pi, "divisor": math.pi, "parter": linparter(["0.5"])} c.insert(pathaxis(path.path(path.moveto(10, 11), path.lineto(18, 11)), lin(texter=rational(numsuffix="\pi", over="%s/%s"), **lintest))) lintest = {"min": 0, "max": 2*math.pi, "divisor": math.pi, "parter": linparter(["0.125"])} c.insert(pathaxis(path.circle(4, 17, 4), lin(texter=rational(suffix="\pi"), **lintest))) lintest = {"min": 0, "max": 2*math.pi, "divisor": math.pi/180, "parter": linparter(["30"])} c.insert(pathaxis(path.circle(14, 17, 4), lin(painter=regular(labeldirection=rotatetext.parallel), **lintest))) c.writeEPSfile("test_axis", page_paperformat=document.paperformat.A4) c.writePDFfile("test_axis", page_paperformat=document.paperformat.A4) c.writeSVGfile("test_axis", page_paperformat=document.paperformat.A4)

gpl-2.0

mbauskar/frappe

frappe/data_migration/doctype/data_migration_connector/connectors/postgres.py

3

1430

from __future__ import unicode_literals import frappe, psycopg2 from .base import BaseConnection class PostGresConnection(BaseConnection): def __init__(self, properties): self.__dict__.update(properties) self._connector = psycopg2.connect("host='{0}' dbname='{1}' user='{2}' password='{3}'".format(self.hostname, self.database_name, self.username, self.password)) self.cursor = self._connector.cursor() def get_objects(self, object_type, condition, selection): if not condition: condition = '' else: condition = ' WHERE ' + condition self.cursor.execute('SELECT {0} FROM {1}{2}'.format(selection, object_type, condition)) raw_data = self.cursor.fetchall() data = [] for r in raw_data: row_dict = frappe._dict({}) for i, value in enumerate(r): row_dict[self.cursor.description[i][0]] = value data.append(row_dict) return data def get_join_objects(self, object_type, field, primary_key): """ field.formula 's first line will be list of tables that needs to be linked to fetch an item The subsequent lines that follows will contain one to one mapping across tables keys """ condition = "" key_mapping = field.formula.split('\n') obj_type = key_mapping[0] selection = field.source_fieldname for d in key_mapping[1:]: condition += d + ' AND ' condition += str(object_type) + ".id=" + str(primary_key) return self.get_objects(obj_type, condition, selection)

mit

parheliamm/mosquitto-1.3.4

test/lib/02-unsubscribe.py

19

1712

#!/usr/bin/env python # Test whether a client sends a correct UNSUBSCRIBE packet. import inspect import os import subprocess import socket import sys import time # From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],".."))) if cmd_subfolder not in sys.path: sys.path.insert(0, cmd_subfolder) import mosq_test rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("unsubscribe-test", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) disconnect_packet = mosq_test.gen_disconnect() mid = 1 unsubscribe_packet = mosq_test.gen_unsubscribe(mid, "unsubscribe/test") unsuback_packet = mosq_test.gen_unsuback(mid) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.settimeout(10) sock.bind(('', 1888)) sock.listen(5) client_args = sys.argv[1:] env = dict(os.environ) env['LD_LIBRARY_PATH'] = '../../lib:../../lib/cpp' try: pp = env['PYTHONPATH'] except KeyError: pp = '' env['PYTHONPATH'] = '../../lib/python:'+pp client = subprocess.Popen(client_args, env=env) try: (conn, address) = sock.accept() conn.settimeout(10) if mosq_test.expect_packet(conn, "connect", connect_packet): conn.send(connack_packet) if mosq_test.expect_packet(conn, "unsubscribe", unsubscribe_packet): conn.send(unsuback_packet) if mosq_test.expect_packet(conn, "disconnect", disconnect_packet): rc = 0 conn.close() finally: client.terminate() client.wait() sock.close() exit(rc)

bsd-3-clause

MrCrawdaddy/humans

humans/urls.py

1

1330

"""humans URL Configuration The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.9/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^$', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.conf.urls import url, include 2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls')) """ from django.conf.urls import include, url from django.contrib import admin from django.contrib.auth import views as auth_views from django.core.urlresolvers import reverse_lazy urlpatterns = [ url(r'^accounts/login/$', auth_views.login, {'template_name': 'documentaries/login.html'}, name='login'), url(r'^accounts/logout/$', auth_views.logout, {'next_page': reverse_lazy('documentaries:index')}, name='logout'), url(r'^accounts/', include('django.contrib.auth.urls')), url(r'^comments/', include('comments.urls')), url(r'^documentaries/', include('documentaries.urls')), url(r'profiles/', include('profiles.urls')), url(r'^admin/', admin.site.urls), ]

mit

shashisp/junction

junction/urls.py

2

3334

# -*- coding: utf-8 -*- from __future__ import absolute_import, unicode_literals # Third Party Stuff from django.conf import settings from django.conf.urls import include, patterns, url from django.conf.urls.static import static from django.contrib import admin from django.views.generic.base import RedirectView, TemplateView from rest_framework import routers from junction.schedule import views as schedule_views from junction.conferences import views as conference_views router = routers.DefaultRouter() router.register('conferences', conference_views.ConferenceView) router.register('venues', conference_views.VenueView) router.register('rooms', conference_views.RoomView) router.register('schedules', schedule_views.ScheduleView) ''' Root url routering file. You should put the url config in their respective app putting only a reference to them here. ''' urlpatterns = patterns( '', # Django Admin url(r'^nimda/', include(admin.site.urls)), # Third Party Stuff url(r'^accounts/', include('allauth.urls')), url('^markdown/', include('django_markdown.urls')), # Proposals related url(r'^(?P<conference_slug>[\w-]+)/proposals/', include('junction.proposals.urls')), url(r'^(?P<conference_slug>[\w-]+)/dashboard/reviewers/', 'junction.proposals.dashboard.reviewer_comments_dashboard', name='proposal-reviewers-dashboard'), url(r'^(?P<conference_slug>[\w-]+)/dashboard/', 'junction.proposals.dashboard.proposals_dashboard', name='proposal-dashboard'), url(r'^api/v1/', include(router.urls)), # User Dashboard url(r'^profiles/', include('junction.profiles.urls', namespace="profiles")), # Schedule related url(r'^(?P<conference_slug>[\w-]+)/schedule/', include('junction.schedule.urls')), # Static Pages. TODO: to be refactored url(r'^speakers/$', TemplateView.as_view(template_name='static-content/speakers.html',), name='speakers-static'), url(r'^schedule/$', TemplateView.as_view(template_name='static-content/schedule.html',), name='schedule-static'), url(r'^venue/$', TemplateView.as_view(template_name='static-content/venue.html',), name='venue-static'), url(r'^sponsors/$', TemplateView.as_view(template_name='static-content/sponsors.html',), name='sponsors-static'), url(r'^blog/$', TemplateView.as_view(template_name='static-content/blog-archive.html',), name='blog-archive'), url(r'^coc/$', TemplateView.as_view(template_name='static-content/coc.html',), name='coc-static'), url(r'^faq/$', TemplateView.as_view(template_name='static-content/faq.html',), name='faq-static'), # Proposals as conference home page. TODO: Needs to be enhanced url(r'^(?P<conference_slug>[\w-]+)--/', RedirectView.as_view(pattern_name="proposals-list"), name='conference-detail'), # add at the last for minor performance gain url(r'^', include('junction.pages.urls', namespace='pages')), ) + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) if settings.DEBUG: urlpatterns += patterns('', url(r'^400/$', 'django.views.defaults.bad_request'), # noqa url(r'^403/$', 'django.views.defaults.permission_denied'), url(r'^404/$', 'django.views.defaults.page_not_found'), url(r'^500/$', 'django.views.defaults.server_error'), )

mit

kslundberg/pants

src/python/pants/binaries/binary_util.py

7

11585

# coding=utf-8 # Copyright 2015 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import (absolute_import, division, generators, nested_scopes, print_function, unicode_literals, with_statement) import logging import os import posixpath import subprocess from contextlib import closing, contextmanager import six.moves.urllib.error as urllib_error import six.moves.urllib.request as urllib_request from twitter.common.collections import OrderedSet from pants.base.exceptions import TaskError from pants.option.custom_types import dict_option, list_option from pants.subsystem.subsystem import Subsystem from pants.util.contextutil import temporary_file from pants.util.dirutil import chmod_plus_x, safe_delete, safe_open from pants.util.osutil import get_os_id _DEFAULT_PATH_BY_ID = { ('linux', 'x86_64'): ['linux', 'x86_64'], ('linux', 'amd64'): ['linux', 'x86_64'], ('linux', 'i386'): ['linux', 'i386'], ('linux', 'i686'): ['linux', 'i386'], ('darwin', '9'): ['mac', '10.5'], ('darwin', '10'): ['mac', '10.6'], ('darwin', '11'): ['mac', '10.7'], ('darwin', '12'): ['mac', '10.8'], ('darwin', '13'): ['mac', '10.9'], ('darwin', '14'): ['mac', '10.10'], ('darwin', '15'): ['mac', '10.11'], } logger = logging.getLogger(__name__) class BinaryUtil(object): """Wraps utility methods for finding binary executables.""" class Factory(Subsystem): options_scope = 'binaries' @classmethod def register_options(cls, register): register('--baseurls', type=list_option, advanced=True, default=['https://dl.bintray.com/pantsbuild/bin/build-support'], help='List of urls from which binary tools are downloaded. Urls are searched in ' 'order until the requested path is found.') register('--fetch-timeout-secs', type=int, default=30, advanced=True, help='Timeout in seconds for url reads when fetching binary tools from the ' 'repos specified by --baseurls') register("--path-by-id", type=dict_option, advanced=True, help='Maps output of uname for a machine to a binary search path. e.g. ' '{ ("darwin", "15"): ["mac", "10.11"]), ("linux", "arm32"): ["linux", "arm32"] }') @classmethod def create(cls): # NB: create is a class method to ~force binary fetch location to be global. options = cls.global_instance().get_options() return BinaryUtil(options.baseurls, options.fetch_timeout_secs, options.pants_bootstrapdir, options.path_by_id) class MissingMachineInfo(TaskError): """Indicates that pants was unable to map this machine's OS to a binary path prefix.""" pass class BinaryNotFound(TaskError): def __init__(self, binary, accumulated_errors): super(BinaryUtil.BinaryNotFound, self).__init__( 'Failed to fetch binary {binary} from any source: ({sources})' .format(binary=binary, sources=', '.join(accumulated_errors))) class NoBaseUrlsError(TaskError): """Indicates that no urls were specified in pants.ini.""" pass class MissingBinaryUtilOptionsError(Exception): """Internal error. --supportdir and --version must be registered in register_options()""" pass def _select_binary_base_path(self, supportdir, version, name, uname_func=None): """Calculate the base path. Exposed for associated unit tests. :param supportdir: the path used to make a path under --pants_bootstrapdir. :param version: the version number of the tool used to make a path under --pants-bootstrapdir. :param name: name of the binary to search for. (e.g 'protoc') :param uname_func: method to use to emulate os.uname() in testing :returns: Base path used to select the binary file. """ uname_func = uname_func or os.uname sysname, _, release, _, machine = uname_func() try: os_id = get_os_id(uname_func=uname_func) except KeyError: os_id = None if os_id is None: raise self.MissingMachineInfo("Pants has no binaries for {}".format(sysname)) try: middle_path = self._path_by_id[os_id] except KeyError: raise self.MissingMachineInfo( "Update --binaries-path-by-id to find binaries for {sysname} {machine} {release}.".format( sysname=sysname, release=release, machine=machine)) return os.path.join(supportdir, *(middle_path + [version, name])) def __init__(self, baseurls, timeout_secs, bootstrapdir, path_by_id=None): """Creates a BinaryUtil with the given settings to define binary lookup behavior. This constructor is primarily used for testing. Production code will usually initialize an instance using the BinaryUtil.Factory.create() method. :param baseurls: URL prefixes which represent repositories of binaries. :type baseurls: list of string :param int timeout_secs: Timeout in seconds for url reads. :param string bootstrapdir: Directory to use for caching binaries. Uses this directory to search for binaries in, or download binaries to if needed. :param dict path_by_id: Additional mapping from (sysname, id) -> (os, arch) for tool directory naming """ self._baseurls = baseurls self._timeout_secs = timeout_secs self._pants_bootstrapdir = bootstrapdir self._path_by_id = _DEFAULT_PATH_BY_ID.copy() if path_by_id: self._path_by_id.update(path_by_id) @contextmanager def _select_binary_stream(self, supportdir, version, name, url_opener=None): """Select a binary matching the current os and architecture. :param string supportdir: The path the `name` binaries are stored under. :param string version: The version number of the binary to select. :param string name: The name of the binary to fetch. :param url_opener: Optional argument used only for testing, to 'pretend' to open urls. :returns: a 'stream' to download it from a support directory. The returned 'stream' is actually a lambda function which returns the files binary contents. :raises: :class:`pants.binary_util.BinaryUtil.BinaryNotFound` if no binary of the given version and name could be found for the current platform. """ if not self._baseurls: raise self.NoBaseUrlsError( 'No urls are defined for the --pants-support-baseurls option.') binary_path = self._select_binary_base_path(supportdir, version, name) if url_opener is None: url_opener = lambda u: closing(urllib_request.urlopen(u, timeout=self._timeout_secs)) downloaded_successfully = False accumulated_errors = [] for baseurl in OrderedSet(self._baseurls): # Wrap in OrderedSet because duplicates are wasteful. url = posixpath.join(baseurl, binary_path) logger.info('Attempting to fetch {name} binary from: {url} ...'.format(name=name, url=url)) try: with url_opener(url) as binary: logger.info('Fetched {name} binary from: {url} .'.format(name=name, url=url)) downloaded_successfully = True yield lambda: binary.read() break except (IOError, urllib_error.HTTPError, urllib_error.URLError, ValueError) as e: accumulated_errors.append('Failed to fetch binary from {url}: {error}' .format(url=url, error=e)) if not downloaded_successfully: raise self.BinaryNotFound((supportdir, version, name), accumulated_errors) def select_binary(self, supportdir, version, name): """Selects a binary matching the current os and architecture. :param string supportdir: The path the `name` binaries are stored under. :param string version: The version number of the binary to select. :param string name: The name of the binary to fetch. :raises: :class:`pants.binary_util.BinaryUtil.BinaryNotFound` if no binary of the given version and name could be found for the current platform. """ # TODO(John Sirois): finish doc of the path structure expected under base_path binary_path = self._select_binary_base_path(supportdir, version, name) bootstrap_dir = os.path.realpath(os.path.expanduser(self._pants_bootstrapdir)) bootstrapped_binary_path = os.path.join(bootstrap_dir, binary_path) if not os.path.exists(bootstrapped_binary_path): downloadpath = bootstrapped_binary_path + '~' try: with self._select_binary_stream(supportdir, version, name) as stream: with safe_open(downloadpath, 'wb') as bootstrapped_binary: bootstrapped_binary.write(stream()) os.rename(downloadpath, bootstrapped_binary_path) chmod_plus_x(bootstrapped_binary_path) finally: safe_delete(downloadpath) logger.debug('Selected {binary} binary bootstrapped to: {path}' .format(binary=name, path=bootstrapped_binary_path)) return bootstrapped_binary_path @contextmanager def safe_args(args, options, max_args=None, argfile=None, delimiter='\n', quoter=None, delete=True): """Yields args if there are less than a limit otherwise writes args to an argfile and yields an argument list with one argument formed from the path of the argfile. :param args: The args to work with. :param OptionValueContainer options: scoped options object for this task :param max_args: The maximum number of args to let though without writing an argfile. If not specified then the maximum will be loaded from the --max-subprocess-args option. :param argfile: The file to write args to when there are too many; defaults to a temporary file. :param delimiter: The delimiter to insert between args written to the argfile, defaults to '\n' :param quoter: A function that can take the argfile path and return a single argument value; defaults to: <code>lambda f: '@' + f<code> :param delete: If True deletes any arg files created upon exit from this context; defaults to True. """ max_args = max_args or options.max_subprocess_args if len(args) > max_args: def create_argfile(f): f.write(delimiter.join(args)) f.close() return [quoter(f.name) if quoter else '@{}'.format(f.name)] if argfile: try: with safe_open(argfile, 'w') as fp: yield create_argfile(fp) finally: if delete and os.path.exists(argfile): os.unlink(argfile) else: with temporary_file(cleanup=delete) as fp: yield create_argfile(fp) else: yield args def _mac_open(files): subprocess.call(['open'] + list(files)) def _linux_open(files): cmd = "xdg-open" if not _cmd_exists(cmd): raise TaskError("The program '{}' isn't in your PATH. Please install and re-run this " "goal.".format(cmd)) for f in list(files): subprocess.call([cmd, f]) # From: http://stackoverflow.com/questions/377017/test-if-executable-exists-in-python def _cmd_exists(cmd): return subprocess.call(["/usr/bin/which", cmd], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE) == 0 _OPENER_BY_OS = { 'darwin': _mac_open, 'linux': _linux_open } def ui_open(*files): """Attempts to open the given files using the preferred native viewer or editor.""" if files: osname = os.uname()[0].lower() if not osname in _OPENER_BY_OS: print('Sorry, open currently not supported for ' + osname) else: _OPENER_BY_OS[osname](files)

apache-2.0

AeonGames/AeonEngine

tools/blender/addons/io_images/export.py

1

1485

# Copyright (C) 2017,2019 Rodrigo Jose Hernandez Cordoba # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import bpy import os class IMG_OT_exporter(bpy.types.Operator): '''Saves All Images in a specified directory''' bl_idname = "export_images.img" bl_label = "All Images" directory: bpy.props.StringProperty(subtype='DIR_PATH') @classmethod def poll(cls, context): return len(bpy.data.images) > 0 def execute(self, context): if len(bpy.data.images) == 0: return {'CANCELLED'} for image in bpy.data.images: filepath = image.filepath image.filepath = self.directory + os.sep + os.path.basename(filepath) print("Saving ",image.filepath) image.save() image.filepath = filepath print("Done.") return {'FINISHED'} def invoke(self, context, event): context.window_manager.fileselect_add(self) return {"RUNNING_MODAL"}

apache-2.0

mjvakili/ccppabc

ccppabc/code/test_emcee.py

1

2414

import sys import numpy as np import emcee from emcee.utils import MPIPool # Choose the "true" parameters. m_true = -0.9594 b_true = 4.294 f_true = 0.534 # Generate some synthetic data from the model. N = 50 x = np.sort(10*np.random.rand(N)) yerr = 0.1+0.5*np.random.rand(N) y = m_true*x+b_true y += np.abs(f_true*y) * np.random.randn(N) y += yerr * np.random.randn(N) A = np.vstack((np.ones_like(x), x)).T C = np.diag(yerr * yerr) cov = np.linalg.inv(np.dot(A.T, np.linalg.solve(C, A))) b_ls, m_ls = np.dot(cov, np.dot(A.T, np.linalg.solve(C, y))) def lnlike(theta, x, y, yerr): m, b, lnf = theta model = m * x + b inv_sigma2 = 1.0/(yerr**2 + model**2*np.exp(2*lnf)) return -0.5*(np.sum((y-model)**2*inv_sigma2 - np.log(inv_sigma2))) import scipy.optimize as op nll = lambda *args: -lnlike(*args) result = op.minimize(nll, [m_true, b_true, np.log(f_true)], args=(x, y, yerr)) m_ml, b_ml, lnf_ml = result["x"] def lnprior(theta): m, b, lnf = theta if -5.0 < m < 0.5 and 0.0 < b < 10.0 and -10.0 < lnf < 1.0: return 0.0 return -np.inf def lnprob(theta, x, y, yerr): lp = lnprior(theta) if not np.isfinite(lp): return -np.inf return lp + lnlike(theta, x, y, yerr) ndim, nwalkers = 3, 100 pos = [result["x"] + 1e-4*np.random.randn(ndim) for i in range(nwalkers)] #pool = MPIPool() #if not pool.is_master(): # pool.wait() # sys.exit(0) sampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob, args=(x, y, yerr)) , threads=15) f = open("chain.dat", "w") f.close() for result in sampler.sample(pos, iterations=600, storechain=False): #print result position = result[0] print position.shape f = open("chain.dat", "a") for k in range(position.shape[0]): output_str = '\t'.join(position[k].astype('str')) + '\n' f.write(output_str) f.close() sampler.run_mcmc(pos, 600) samples = sampler.chain[:, 100:, :].reshape((-1, ndim)) #pool.close() #import corner #fig = corner.corner(samples, labels=["$m$", "$b$", "$\ln\,f$"], # truths=[m_true, b_true, np.log(f_true)]) #fig.savefig("/home/mj/public_html/triangle_final.png") # #samples2 = np.loadtxt("chain.dat") # #fig = corner.corner(samples2[100:], labels=["$m$", "$b$", "$\ln\,f$"], # truths=[m_true, b_true, np.log(f_true)]) # #fig.savefig("/home/mj/public_html/triangle_incremental.png")

mit

redhat-openstack/trove

trove/tests/unittests/api/test_versions.py

3

8858

# Copyright 2013 OpenStack Foundation # Copyright 2013 Hewlett-Packard Development Company, L.P. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from mock import Mock from trove.tests.unittests import trove_testtools from trove.versions import BaseVersion from trove.versions import Version from trove.versions import VersionDataView from trove.versions import VERSIONS from trove.versions import VersionsAPI from trove.versions import VersionsController from trove.versions import VersionsDataView BASE_URL = 'http://localhost' class VersionsControllerTest(trove_testtools.TestCase): def setUp(self): super(VersionsControllerTest, self).setUp() self.controller = VersionsController() self.assertIsNotNone(self.controller, "VersionsController instance was None") def test_index_json(self): request = Mock() result = self.controller.index(request) self.assertIsNotNone(result, 'Result was None') result._data = Mock() result._data.data_for_json = \ lambda: {'status': 'CURRENT', 'updated': '2012-08-01T00:00:00Z', 'id': 'v1.0', 'links': [{'href': 'http://localhost/v1.0/', 'rel': 'self'}]} # can be anything but xml json_data = result.data("application/json") self.assertIsNotNone(json_data, 'Result json_data was None') self.assertEqual('v1.0', json_data['id'], 'Version id is incorrect') self.assertEqual('CURRENT', json_data['status'], 'Version status is incorrect') self.assertEqual('2012-08-01T00:00:00Z', json_data['updated'], 'Version updated value is incorrect') def test_show_json(self): request = Mock() request.url_version = '1.0' result = self.controller.show(request) self.assertIsNotNone(result, 'Result was None') json_data = result.data("application/json") self.assertIsNotNone(json_data, "JSON data was None") version = json_data.get('version', None) self.assertIsNotNone(version, "Version was None") self.assertEqual('CURRENT', version['status'], "Version status was not 'CURRENT'") self.assertEqual('2012-08-01T00:00:00Z', version['updated'], "Version updated was not '2012-08-01T00:00:00Z'") self.assertEqual('v1.0', version['id'], "Version id was not 'v1.0'") class BaseVersionTestCase(trove_testtools.TestCase): def setUp(self): super(BaseVersionTestCase, self).setUp() id = VERSIONS['1.0']['id'] status = VERSIONS['1.0']['status'] base_url = BASE_URL updated = VERSIONS['1.0']['updated'] self.base_version = BaseVersion(id, status, base_url, updated) self.assertIsNotNone(self.base_version, 'BaseVersion instance was None') def test_data(self): data = self.base_version.data() self.assertIsNotNone(data, 'Base Version data was None') self.assertTrue(type(data) is dict, "Base Version data is not a dict") self.assertEqual('CURRENT', data['status'], "Data status was not 'CURRENT'") self.assertEqual('2012-08-01T00:00:00Z', data['updated'], "Data updated was not '2012-08-01T00:00:00Z'") self.assertEqual('v1.0', data['id'], "Data status was not 'v1.0'") def test_url(self): url = self.base_version.url() self.assertIsNotNone(url, 'Url was None') self.assertEqual('http://localhost/v1.0/', url, "Base Version url is incorrect") class VersionTestCase(trove_testtools.TestCase): def setUp(self): super(VersionTestCase, self).setUp() id = VERSIONS['1.0']['id'] status = VERSIONS['1.0']['status'] base_url = BASE_URL updated = VERSIONS['1.0']['updated'] self.version = Version(id, status, base_url, updated) self.assertIsNotNone(self.version, 'Version instance was None') def test_url_no_trailing_slash(self): url = self.version.url() self.assertIsNotNone(url, 'Version url was None') self.assertEqual(BASE_URL + '/', url, 'Base url value was incorrect') def test_url_with_trailing_slash(self): self.version.base_url = 'http://localhost/' url = self.version.url() self.assertEqual(BASE_URL + '/', url, 'Base url value was incorrect') class VersionDataViewTestCase(trove_testtools.TestCase): def setUp(self): super(VersionDataViewTestCase, self).setUp() # get a version object first id = VERSIONS['1.0']['id'] status = VERSIONS['1.0']['status'] base_url = BASE_URL updated = VERSIONS['1.0']['updated'] self.version = Version(id, status, base_url, updated) self.assertIsNotNone(self.version, 'Version instance was None') # then create an instance of VersionDataView self.version_data_view = VersionDataView(self.version) self.assertIsNotNone(self.version_data_view, 'Version Data view instance was None') def test_data_for_json(self): json_data = self.version_data_view.data_for_json() self.assertIsNotNone(json_data, "JSON data was None") self.assertTrue(type(json_data) is dict, "JSON version data is not a dict") self.assertIsNotNone(json_data.get('version'), "Dict json_data has no key 'version'") data = json_data['version'] self.assertIsNotNone(data, "JSON data version was None") self.assertEqual('CURRENT', data['status'], "Data status was not 'CURRENT'") self.assertEqual('2012-08-01T00:00:00Z', data['updated'], "Data updated was not '2012-08-01T00:00:00Z'") self.assertEqual('v1.0', data['id'], "Data status was not 'v1.0'") class VersionsDataViewTestCase(trove_testtools.TestCase): def setUp(self): super(VersionsDataViewTestCase, self).setUp() # get a version object, put it in a list self.versions = [] id = VERSIONS['1.0']['id'] status = VERSIONS['1.0']['status'] base_url = BASE_URL updated = VERSIONS['1.0']['updated'] self.version = Version(id, status, base_url, updated) self.assertIsNotNone(self.version, 'Version instance was None') self.versions.append(self.version) # then create an instance of VersionsDataView self.versions_data_view = VersionsDataView(self.versions) self.assertIsNotNone(self.versions_data_view, 'Versions Data view instance was None') def test_data_for_json(self): json_data = self.versions_data_view.data_for_json() self.assertIsNotNone(json_data, "JSON data was None") self.assertTrue(type(json_data) is dict, "JSON versions data is not a dict") self.assertIsNotNone(json_data.get('versions', None), "Dict json_data has no key 'versions'") versions = json_data['versions'] self.assertIsNotNone(versions, "Versions was None") self.assertEqual(1, len(versions), "Versions length != 1") # explode the version object versions_data = [v.data() for v in self.versions] d1 = versions_data.pop() d2 = versions.pop() self.assertEqual(d1['id'], d2['id'], "Version ids are not equal") class VersionAPITestCase(trove_testtools.TestCase): def setUp(self): super(VersionAPITestCase, self).setUp() def test_instance(self): self.versions_api = VersionsAPI() self.assertIsNotNone(self.versions_api, "VersionsAPI instance was None")

apache-2.0

Ryanglambert/pybrain

docs/tutorials/networks.py

25

4239

from __future__ import print_function ############################################################################ # PyBrain Tutorial "Networks, Modules, Connections" # # Author: Tom Schaul, tom@idsia.ch ############################################################################ __author__ = 'Tom Schaul, tom@idsia.ch' from pybrain.structure import FeedForwardNetwork, LinearLayer, SigmoidLayer, FullConnection, RecurrentNetwork from pybrain.tools.shortcuts import buildNetwork """ This tutorial will attempt to guide you for using one of PyBrain's most basic structural elements: Networks, and with them Modules and Connections. Let us start with a simple example, building a multi-layer-perceptron (MLP). First we make a new network object: """ n = FeedForwardNetwork() """ Next, we're constructing the input, hidden and output layers. """ inLayer = LinearLayer(2) hiddenLayer = SigmoidLayer(3) outLayer = LinearLayer(1) """ (Note that we could also have used a hidden layer of type TanhLayer, LinearLayer, etc.) Let's add them to the network: """ n.addInputModule(inLayer) n.addModule(hiddenLayer) n.addOutputModule(outLayer) """ We still need to explicitly determine how they should be connected. For this we use the most common connection type, which produces a full connectivity between two layers (or Modules, in general): the 'FullConnection'. """ in2hidden = FullConnection(inLayer, hiddenLayer) hidden2out = FullConnection(hiddenLayer, outLayer) n.addConnection(in2hidden) n.addConnection(hidden2out) """ All the elements are in place now, so we can do the final step that makes our MLP usable, which is to call the 'sortModules()' method. """ n.sortModules() """ Let's see what we did. """ print(n) """ One way of using the network is to call its 'activate()' method with an input to be transformed. """ print(n.activate([1, 2])) """ We can access the trainable parameters (weights) of a connection directly, or read all weights of the network at once. """ print(hidden2out.params) print(n.params) """ The former are the last slice of the latter. """ print(n.params[-3:] == hidden2out.params) """ Ok, after having covered the basics, let's move on to some additional concepts. First of all, we encourage you to name all modules, or connections you create, because that gives you more readable printouts, and a very concise way of accessing them. We now build an equivalent network to the one before, but with a more concise syntax: """ n2 = RecurrentNetwork(name='net2') n2.addInputModule(LinearLayer(2, name='in')) n2.addModule(SigmoidLayer(3, name='h')) n2.addOutputModule(LinearLayer(1, name='out')) n2.addConnection(FullConnection(n2['in'], n2['h'], name='c1')) n2.addConnection(FullConnection(n2['h'], n2['out'], name='c2')) n2.sortModules() """ Printouts look more concise and readable: """ print(n2) """ There is an even quicker way to build networks though, as long as their structure is nothing more fancy than a stack of fully connected layers: """ n3 = buildNetwork(2, 3, 1, bias=False) """ Recurrent networks are working in the same way, except that the recurrent connections need to be explicitly declared upon construction. We can modify our existing network 'net2' and add a recurrent connection on the hidden layer: """ n2.addRecurrentConnection(FullConnection(n2['h'], n2['h'], name='rec')) """ After every structural modification, if we want ot use the network, we call 'sortModules()' again""" n2.sortModules() print(n2) """ As the network is now recurrent, successive activations produce different outputs: """ print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2])) """ The 'reset()' method re-initializes the network, and with it sets the recurrent activations to zero, so now we get the same results: """ n2.reset() print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2]), end=' ') print(n2.activate([1, 2])) """ This is already a good coverage of the basics, but if you're an advanced user you might want to find out about the possibilities of nesting networks within others, using weight-sharing, and more exotic types of networks, connections and modules... but that goes beyond the scope of this tutorial. """

bsd-3-clause

verdverm/pypge

experiments/01_baseline/theann.py

1

3775

from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np import pandas as pd from sklearn.metrics import r2_score import data as DATA import tensorflow.python.platform import tensorflow as tf def run_explicit_loop(): for problem in DATA.explicit_problems: prob,target = problem.split(";") df = DATA.read_datafile("explicit", prob) cols = [col for col in df.columns if not (col == target or col == "T" or (len(col)>2 and col[:2] == "D_"))] ins = df[cols].as_matrix() outs = df[target].values print("\n\n", prob, target, ins.shape, outs.shape, "\n=======================\n") ann_model(ins,outs, 24,24) for problem in DATA.diffeq_problems: prob,target = problem.split(";") df = DATA.read_datafile("diffeq", prob) cols = [col for col in df.columns if not (col == target or col == "T" or (len(col)>2 and col[:2] == "D_"))] ins = df[cols].as_matrix() outs = df[target].values print("\n\n", prob, target, ins.shape, outs.shape, "\n=======================\n") ann_model(ins,outs, 24,24) def print_model(name, regr, ins, outs): print(" ",name,"\n--------------") # The mean square error yhat = regr.predict(ins) print(" Residual: %g" % np.mean((yhat - outs) ** 2)) # Explained variance score: 1 is perfect prediction r2 = r2_score(outs, yhat) print(' R2: %g' % r2) print() # Create model def multilayer_perceptron(_X, _weights, _biases): layer_1 = tf.nn.relu(tf.add(tf.matmul(_X, _weights['h1']), _biases['b1'])) #Hidden layer with RELU activation layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, _weights['h2']), _biases['b2'])) #Hidden layer with RELU activation return tf.matmul(layer_2, _weights['out']) + _biases['out'] # layer_3 = tf.nn.relu(tf.add(tf.matmul(layer_2, _weights['h3']), _biases['b3'])) #Hidden layer with RELU activation # return tf.matmul(layer_3, _weights['out']) + _biases['out'] def ann_model(ins, outs, n_hidden_1, n_hidden_2): outs = outs.reshape(len(outs),1) n_input = len(ins[0]) n_samples = len(outs) # tf Graph input x = tf.placeholder("float", [n_samples, n_input]) y = tf.placeholder("float", [n_samples, 1]) # Store layers weight & bias weights = { 'h1': tf.Variable(tf.truncated_normal([n_input, n_hidden_1], stddev=0.1)), 'h2': tf.Variable(tf.truncated_normal([n_hidden_1, n_hidden_2], stddev=0.1)), 'out': tf.Variable(tf.truncated_normal([n_hidden_2, 1], stddev=0.1)) # 'h3': tf.Variable(tf.truncated_normal([n_hidden_2, n_hidden_3], stddev=0.1)), # 'out': tf.Variable(tf.truncated_normal([n_hidden_3, 1], stddev=0.1)) } biases = { 'b1': tf.Variable(tf.constant(0.1, shape=[n_hidden_1])), 'b2': tf.Variable(tf.constant(0.1, shape=[n_hidden_2])), # 'b3': tf.Variable(tf.constant(0.1, shape=[n_hidden_3])), 'out': tf.Variable(tf.constant(0.1, shape=[1])) } # Construct model pred = multilayer_perceptron(x, weights, biases) ## use mean sqr error for cost function cost = (tf.pow(y-pred, 2)) accuracy = tf.reduce_mean(cost) # construct an optimizer to minimize cost and fit the data train_op = tf.train.AdamOptimizer(0.01).minimize(accuracy) sess = tf.Session() init = tf.initialize_all_variables() sess.run(init) NUM_EPOCH = 2501 DISPLAY = 100 a_sum = 0 for epoch in range(NUM_EPOCH): sess.run(train_op, feed_dict={x: ins, y: outs}) # c = sess.run(cost, feed_dict={x: ins, y: outs}) if epoch % DISPLAY == 0: a = sess.run(accuracy, feed_dict={x: ins, y: outs}) print(epoch, a) a = sess.run(accuracy, feed_dict={x: ins, y: outs}) print("Final: ", a) y_hat = sess.run(pred, feed_dict={x: ins, y: outs}) r2 = r2_score(outs, y_hat) print("R2: ", r2) run_explicit_loop()

mit

freeflightsim/ffs-app-engine

ffs-cal.appspot.com/atom/core.py

18

20432

#!/usr/bin/env python # # Copyright (C) 2008 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # This module is used for version 2 of the Google Data APIs. __author__ = 'j.s@google.com (Jeff Scudder)' import inspect try: from xml.etree import cElementTree as ElementTree except ImportError: try: import cElementTree as ElementTree except ImportError: try: from xml.etree import ElementTree except ImportError: from elementtree import ElementTree STRING_ENCODING = 'utf-8' class XmlElement(object): """Represents an element node in an XML document. The text member is a UTF-8 encoded str or unicode. """ _qname = None _other_elements = None _other_attributes = None # The rule set contains mappings for XML qnames to child members and the # appropriate member classes. _rule_set = None _members = None text = None def __init__(self, text=None, *args, **kwargs): if ('_members' not in self.__class__.__dict__ or self.__class__._members is None): self.__class__._members = tuple(self.__class__._list_xml_members()) for member_name, member_type in self.__class__._members: if member_name in kwargs: setattr(self, member_name, kwargs[member_name]) else: if isinstance(member_type, list): setattr(self, member_name, []) else: setattr(self, member_name, None) self._other_elements = [] self._other_attributes = {} if text is not None: self.text = text def _list_xml_members(cls): """Generator listing all members which are XML elements or attributes. The following members would be considered XML members: foo = 'abc' - indicates an XML attribute with the qname abc foo = SomeElement - indicates an XML child element foo = [AnElement] - indicates a repeating XML child element, each instance will be stored in a list in this member foo = ('att1', '{http://example.com/namespace}att2') - indicates an XML attribute which has different parsing rules in different versions of the protocol. Version 1 of the XML parsing rules will look for an attribute with the qname 'att1' but verion 2 of the parsing rules will look for a namespaced attribute with the local name of 'att2' and an XML namespace of 'http://example.com/namespace'. """ members = [] for pair in inspect.getmembers(cls): if not pair[0].startswith('_') and pair[0] != 'text': member_type = pair[1] if (isinstance(member_type, tuple) or isinstance(member_type, list) or isinstance(member_type, (str, unicode)) or (inspect.isclass(member_type) and issubclass(member_type, XmlElement))): members.append(pair) return members _list_xml_members = classmethod(_list_xml_members) def _get_rules(cls, version): """Initializes the _rule_set for the class which is used when parsing XML. This method is used internally for parsing and generating XML for an XmlElement. It is not recommended that you call this method directly. Returns: A tuple containing the XML parsing rules for the appropriate version. The tuple looks like: (qname, {sub_element_qname: (member_name, member_class, repeating), ..}, {attribute_qname: member_name}) To give a couple of concrete example, the atom.data.Control _get_rules with version of 2 will return: ('{http://www.w3.org/2007/app}control', {'{http://www.w3.org/2007/app}draft': ('draft', <class 'atom.data.Draft'>, False)}, {}) Calling _get_rules with version 1 on gdata.data.FeedLink will produce: ('{http://schemas.google.com/g/2005}feedLink', {'{http://www.w3.org/2005/Atom}feed': ('feed', <class 'gdata.data.GDFeed'>, False)}, {'href': 'href', 'readOnly': 'read_only', 'countHint': 'count_hint', 'rel': 'rel'}) """ # Initialize the _rule_set to make sure there is a slot available to store # the parsing rules for this version of the XML schema. # Look for rule set in the class __dict__ proxy so that only the # _rule_set for this class will be found. By using the dict proxy # we avoid finding rule_sets defined in superclasses. # The four lines below provide support for any number of versions, but it # runs a bit slower then hard coding slots for two versions, so I'm using # the below two lines. #if '_rule_set' not in cls.__dict__ or cls._rule_set is None: # cls._rule_set = [] #while len(cls.__dict__['_rule_set']) < version: # cls._rule_set.append(None) # If there is no rule set cache in the class, provide slots for two XML # versions. If and when there is a version 3, this list will need to be # expanded. if '_rule_set' not in cls.__dict__ or cls._rule_set is None: cls._rule_set = [None, None] # If a version higher than 2 is requested, fall back to version 2 because # 2 is currently the highest supported version. if version > 2: return cls._get_rules(2) # Check the dict proxy for the rule set to avoid finding any rule sets # which belong to the superclass. We only want rule sets for this class. if cls._rule_set[version-1] is None: # The rule set for each version consists of the qname for this element # ('{namespace}tag'), a dictionary (elements) for looking up the # corresponding class member when given a child element's qname, and a # dictionary (attributes) for looking up the corresponding class member # when given an XML attribute's qname. elements = {} attributes = {} if ('_members' not in cls.__dict__ or cls._members is None): cls._members = tuple(cls._list_xml_members()) for member_name, target in cls._members: if isinstance(target, list): # This member points to a repeating element. elements[_get_qname(target[0], version)] = (member_name, target[0], True) elif isinstance(target, tuple): # This member points to a versioned XML attribute. if version <= len(target): attributes[target[version-1]] = member_name else: attributes[target[-1]] = member_name elif isinstance(target, (str, unicode)): # This member points to an XML attribute. attributes[target] = member_name elif issubclass(target, XmlElement): # This member points to a single occurance element. elements[_get_qname(target, version)] = (member_name, target, False) version_rules = (_get_qname(cls, version), elements, attributes) cls._rule_set[version-1] = version_rules return version_rules else: return cls._rule_set[version-1] _get_rules = classmethod(_get_rules) def get_elements(self, tag=None, namespace=None, version=1): """Find all sub elements which match the tag and namespace. To find all elements in this object, call get_elements with the tag and namespace both set to None (the default). This method searches through the object's members and the elements stored in _other_elements which did not match any of the XML parsing rules for this class. Args: tag: str namespace: str version: int Specifies the version of the XML rules to be used when searching for matching elements. Returns: A list of the matching XmlElements. """ matches = [] ignored1, elements, ignored2 = self.__class__._get_rules(version) if elements: for qname, element_def in elements.iteritems(): member = getattr(self, element_def[0]) if member: if _qname_matches(tag, namespace, qname): if element_def[2]: # If this is a repeating element, copy all instances into the # result list. matches.extend(member) else: matches.append(member) for element in self._other_elements: if _qname_matches(tag, namespace, element._qname): matches.append(element) return matches GetElements = get_elements # FindExtensions and FindChildren are provided for backwards compatibility # to the atom.AtomBase class. # However, FindExtensions may return more results than the v1 atom.AtomBase # method does, because get_elements searches both the expected children # and the unexpected "other elements". The old AtomBase.FindExtensions # method searched only "other elements" AKA extension_elements. FindExtensions = get_elements FindChildren = get_elements def get_attributes(self, tag=None, namespace=None, version=1): """Find all attributes which match the tag and namespace. To find all attributes in this object, call get_attributes with the tag and namespace both set to None (the default). This method searches through the object's members and the attributes stored in _other_attributes which did not fit any of the XML parsing rules for this class. Args: tag: str namespace: str version: int Specifies the version of the XML rules to be used when searching for matching attributes. Returns: A list of XmlAttribute objects for the matching attributes. """ matches = [] ignored1, ignored2, attributes = self.__class__._get_rules(version) if attributes: for qname, attribute_def in attributes.iteritems(): if isinstance(attribute_def, (list, tuple)): attribute_def = attribute_def[0] member = getattr(self, attribute_def) # TODO: ensure this hasn't broken existing behavior. #member = getattr(self, attribute_def[0]) if member: if _qname_matches(tag, namespace, qname): matches.append(XmlAttribute(qname, member)) for qname, value in self._other_attributes.iteritems(): if _qname_matches(tag, namespace, qname): matches.append(XmlAttribute(qname, value)) return matches GetAttributes = get_attributes def _harvest_tree(self, tree, version=1): """Populates object members from the data in the tree Element.""" qname, elements, attributes = self.__class__._get_rules(version) for element in tree: if elements and element.tag in elements: definition = elements[element.tag] # If this is a repeating element, make sure the member is set to a # list. if definition[2]: if getattr(self, definition[0]) is None: setattr(self, definition[0], []) getattr(self, definition[0]).append(_xml_element_from_tree(element, definition[1], version)) else: setattr(self, definition[0], _xml_element_from_tree(element, definition[1], version)) else: self._other_elements.append(_xml_element_from_tree(element, XmlElement, version)) for attrib, value in tree.attrib.iteritems(): if attributes and attrib in attributes: setattr(self, attributes[attrib], value) else: self._other_attributes[attrib] = value if tree.text: self.text = tree.text def _to_tree(self, version=1, encoding=None): new_tree = ElementTree.Element(_get_qname(self, version)) self._attach_members(new_tree, version, encoding) return new_tree def _attach_members(self, tree, version=1, encoding=None): """Convert members to XML elements/attributes and add them to the tree. Args: tree: An ElementTree.Element which will be modified. The members of this object will be added as child elements or attributes according to the rules described in _expected_elements and _expected_attributes. The elements and attributes stored in other_attributes and other_elements are also added a children of this tree. version: int Ingnored in this method but used by VersionedElement. encoding: str (optional) """ qname, elements, attributes = self.__class__._get_rules(version) encoding = encoding or STRING_ENCODING # Add the expected elements and attributes to the tree. if elements: for tag, element_def in elements.iteritems(): member = getattr(self, element_def[0]) # If this is a repeating element and there are members in the list. if member and element_def[2]: for instance in member: instance._become_child(tree, version) elif member: member._become_child(tree, version) if attributes: for attribute_tag, member_name in attributes.iteritems(): value = getattr(self, member_name) if value: tree.attrib[attribute_tag] = value # Add the unexpected (other) elements and attributes to the tree. for element in self._other_elements: element._become_child(tree, version) for key, value in self._other_attributes.iteritems(): # I'm not sure if unicode can be used in the attribute name, so for now # we assume the encoding is correct for the attribute name. if not isinstance(value, unicode): value = value.decode(encoding) tree.attrib[key] = value if self.text: if isinstance(self.text, unicode): tree.text = self.text else: tree.text = self.text.decode(encoding) def to_string(self, version=1, encoding=None): """Converts this object to XML.""" return ElementTree.tostring(self._to_tree(version, encoding)) ToString = to_string def __str__(self): return self.to_string() def _become_child(self, tree, version=1): """Adds a child element to tree with the XML data in self.""" new_child = ElementTree.Element('') tree.append(new_child) new_child.tag = _get_qname(self, version) self._attach_members(new_child, version) def __get_extension_elements(self): return self._other_elements def __set_extension_elements(self, elements): self._other_elements = elements extension_elements = property(__get_extension_elements, __set_extension_elements, """Provides backwards compatibility for v1 atom.AtomBase classes.""") def __get_extension_attributes(self): return self._other_attributes def __set_extension_attributes(self, attributes): self._other_attributes = attributes extension_attributes = property(__get_extension_attributes, __set_extension_attributes, """Provides backwards compatibility for v1 atom.AtomBase classes.""") def _get_tag(self, version=1): qname = _get_qname(self, version) return qname[qname.find('}')+1:] def _get_namespace(self, version=1): qname = _get_qname(self, version) if qname.startswith('{'): return qname[1:qname.find('}')] else: return None def _set_tag(self, tag): if isinstance(self._qname, tuple): self._qname = self._qname.copy() if self._qname[0].startswith('{'): self._qname[0] = '{%s}%s' % (self._get_namespace(1), tag) else: self._qname[0] = tag else: if self._qname.startswith('{'): self._qname = '{%s}%s' % (self._get_namespace(), tag) else: self._qname = tag def _set_namespace(self, namespace): if isinstance(self._qname, tuple): self._qname = self._qname.copy() if namespace: self._qname[0] = '{%s}%s' % (namespace, self._get_tag(1)) else: self._qname[0] = self._get_tag(1) else: if namespace: self._qname = '{%s}%s' % (namespace, self._get_tag(1)) else: self._qname = self._get_tag(1) tag = property(_get_tag, _set_tag, """Provides backwards compatibility for v1 atom.AtomBase classes.""") namespace = property(_get_namespace, _set_namespace, """Provides backwards compatibility for v1 atom.AtomBase classes.""") # Provided for backwards compatibility to atom.ExtensionElement children = extension_elements attributes = extension_attributes def _get_qname(element, version): if isinstance(element._qname, tuple): if version <= len(element._qname): return element._qname[version-1] else: return element._qname[-1] else: return element._qname def _qname_matches(tag, namespace, qname): """Logic determines if a QName matches the desired local tag and namespace. This is used in XmlElement.get_elements and XmlElement.get_attributes to find matches in the element's members (among all expected-and-unexpected elements-and-attributes). Args: expected_tag: string expected_namespace: string qname: string in the form '{xml_namespace}localtag' or 'tag' if there is no namespace. Returns: boolean True if the member's tag and namespace fit the expected tag and namespace. """ # If there is no expected namespace or tag, then everything will match. if qname is None: member_tag = None member_namespace = None else: if qname.startswith('{'): member_namespace = qname[1:qname.index('}')] member_tag = qname[qname.index('}') + 1:] else: member_namespace = None member_tag = qname return ((tag is None and namespace is None) # If there is a tag, but no namespace, see if the local tag matches. or (namespace is None and member_tag == tag) # There was no tag, but there was a namespace so see if the namespaces # match. or (tag is None and member_namespace == namespace) # There was no tag, and the desired elements have no namespace, so check # to see that the member's namespace is None. or (tag is None and namespace == '' and member_namespace is None) # The tag and the namespace both match. or (tag == member_tag and namespace == member_namespace) # The tag matches, and the expected namespace is the empty namespace, # check to make sure the member's namespace is None. or (tag == member_tag and namespace == '' and member_namespace is None)) def parse(xml_string, target_class=None, version=1, encoding=None): """Parses the XML string according to the rules for the target_class. Args: xml_string: str or unicode target_class: XmlElement or a subclass. If None is specified, the XmlElement class is used. version: int (optional) The version of the schema which should be used when converting the XML into an object. The default is 1. encoding: str (optional) The character encoding of the bytes in the xml_string. Default is 'UTF-8'. """ if target_class is None: target_class = XmlElement if isinstance(xml_string, unicode): if encoding is None: xml_string = xml_string.encode(STRING_ENCODING) else: xml_string = xml_string.encode(encoding) tree = ElementTree.fromstring(xml_string) return _xml_element_from_tree(tree, target_class, version) Parse = parse xml_element_from_string = parse XmlElementFromString = xml_element_from_string def _xml_element_from_tree(tree, target_class, version=1): if target_class._qname is None: instance = target_class() instance._qname = tree.tag instance._harvest_tree(tree, version) return instance # TODO handle the namespace-only case # Namespace only will be used with Google Spreadsheets rows and # Google Base item attributes. elif tree.tag == _get_qname(target_class, version): instance = target_class() instance._harvest_tree(tree, version) return instance return None class XmlAttribute(object): def __init__(self, qname, value): self._qname = qname self.value = value

gpl-2.0

xuxiao19910803/edx

lms/djangoapps/ccx/views.py

9

19058

""" Views related to the Custom Courses feature. """ import csv import datetime import functools import json import logging import pytz from contextlib import contextmanager from copy import deepcopy from cStringIO import StringIO from django.core.urlresolvers import reverse from django.http import ( HttpResponse, HttpResponseForbidden, ) from django.contrib import messages from django.core.exceptions import ValidationError from django.core.validators import validate_email from django.http import Http404 from django.shortcuts import redirect from django.utils.translation import ugettext as _ from django.views.decorators.cache import cache_control from django.views.decorators.csrf import ensure_csrf_cookie from django.contrib.auth.models import User from courseware.courses import get_course_by_id from courseware.field_overrides import disable_overrides from courseware.grades import iterate_grades_for from courseware.model_data import FieldDataCache from courseware.module_render import get_module_for_descriptor from edxmako.shortcuts import render_to_response from opaque_keys.edx.keys import CourseKey from ccx_keys.locator import CCXLocator from student.roles import CourseCcxCoachRole from instructor.offline_gradecalc import student_grades from instructor.views.api import _split_input_list from instructor.views.tools import get_student_from_identifier from .models import CustomCourseForEdX, CcxMembership from .overrides import ( clear_override_for_ccx, get_override_for_ccx, override_field_for_ccx, ) from .utils import ( enroll_email, unenroll_email, ) log = logging.getLogger(__name__) TODAY = datetime.datetime.today # for patching in tests def coach_dashboard(view): """ View decorator which enforces that the user have the CCX coach role on the given course and goes ahead and translates the course_id from the Django route into a course object. """ @functools.wraps(view) def wrapper(request, course_id): """ Wraps the view function, performing access check, loading the course, and modifying the view's call signature. """ course_key = CourseKey.from_string(course_id) ccx = None if isinstance(course_key, CCXLocator): ccx_id = course_key.ccx ccx = CustomCourseForEdX.objects.get(pk=ccx_id) course_key = ccx.course_id role = CourseCcxCoachRole(course_key) if not role.has_user(request.user): return HttpResponseForbidden( _('You must be a CCX Coach to access this view.')) course = get_course_by_id(course_key, depth=None) # if there is a ccx, we must validate that it is the ccx for this coach if ccx is not None: coach_ccx = get_ccx_for_coach(course, request.user) if coach_ccx is None or coach_ccx.id != ccx.id: return HttpResponseForbidden( _('You must be the coach for this ccx to access this view') ) return view(request, course, ccx) return wrapper @ensure_csrf_cookie @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def dashboard(request, course, ccx=None): """ Display the CCX Coach Dashboard. """ # right now, we can only have one ccx per user and course # so, if no ccx is passed in, we can sefely redirect to that if ccx is None: ccx = get_ccx_for_coach(course, request.user) if ccx: url = reverse( 'ccx_coach_dashboard', kwargs={'course_id': CCXLocator.from_course_locator(course.id, ccx.id)} ) return redirect(url) context = { 'course': course, 'ccx': ccx, } if ccx: ccx_locator = CCXLocator.from_course_locator(course.id, ccx.id) schedule = get_ccx_schedule(course, ccx) grading_policy = get_override_for_ccx( ccx, course, 'grading_policy', course.grading_policy) context['schedule'] = json.dumps(schedule, indent=4) context['save_url'] = reverse( 'save_ccx', kwargs={'course_id': ccx_locator}) context['ccx_members'] = CcxMembership.objects.filter(ccx=ccx) context['gradebook_url'] = reverse( 'ccx_gradebook', kwargs={'course_id': ccx_locator}) context['grades_csv_url'] = reverse( 'ccx_grades_csv', kwargs={'course_id': ccx_locator}) context['grading_policy'] = json.dumps(grading_policy, indent=4) context['grading_policy_url'] = reverse( 'ccx_set_grading_policy', kwargs={'course_id': ccx_locator}) else: context['create_ccx_url'] = reverse( 'create_ccx', kwargs={'course_id': course.id}) return render_to_response('ccx/coach_dashboard.html', context) @ensure_csrf_cookie @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def create_ccx(request, course, ccx=None): """ Create a new CCX """ name = request.POST.get('name') # prevent CCX objects from being created for deprecated course ids. if course.id.deprecated: messages.error(request, _( "You cannot create a CCX from a course using a deprecated id. " "Please create a rerun of this course in the studio to allow " "this action.")) url = reverse('ccx_coach_dashboard', kwargs={'course_id', course.id}) return redirect(url) ccx = CustomCourseForEdX( course_id=course.id, coach=request.user, display_name=name) ccx.save() # Make sure start/due are overridden for entire course start = TODAY().replace(tzinfo=pytz.UTC) override_field_for_ccx(ccx, course, 'start', start) override_field_for_ccx(ccx, course, 'due', None) # Hide anything that can show up in the schedule hidden = 'visible_to_staff_only' for chapter in course.get_children(): override_field_for_ccx(ccx, chapter, hidden, True) for sequential in chapter.get_children(): override_field_for_ccx(ccx, sequential, hidden, True) for vertical in sequential.get_children(): override_field_for_ccx(ccx, vertical, hidden, True) ccx_id = CCXLocator.from_course_locator(course.id, ccx.id) # pylint: disable=no-member url = reverse('ccx_coach_dashboard', kwargs={'course_id': ccx_id}) return redirect(url) @ensure_csrf_cookie @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def save_ccx(request, course, ccx=None): """ Save changes to CCX. """ if not ccx: raise Http404 def override_fields(parent, data, graded, earliest=None): """ Recursively apply CCX schedule data to CCX by overriding the `visible_to_staff_only`, `start` and `due` fields for units in the course. """ blocks = { str(child.location): child for child in parent.get_children()} for unit in data: block = blocks[unit['location']] override_field_for_ccx( ccx, block, 'visible_to_staff_only', unit['hidden']) start = parse_date(unit['start']) if start: if not earliest or start < earliest: earliest = start override_field_for_ccx(ccx, block, 'start', start) else: clear_override_for_ccx(ccx, block, 'start') due = parse_date(unit['due']) if due: override_field_for_ccx(ccx, block, 'due', due) else: clear_override_for_ccx(ccx, block, 'due') if not unit['hidden'] and block.graded: graded[block.format] = graded.get(block.format, 0) + 1 children = unit.get('children', None) if children: override_fields(block, children, graded, earliest) return earliest graded = {} earliest = override_fields(course, json.loads(request.body), graded) if earliest: override_field_for_ccx(ccx, course, 'start', earliest) # Attempt to automatically adjust grading policy changed = False policy = get_override_for_ccx( ccx, course, 'grading_policy', course.grading_policy ) policy = deepcopy(policy) grader = policy['GRADER'] for section in grader: count = graded.get(section.get('type'), 0) if count < section['min_count']: changed = True section['min_count'] = count if changed: override_field_for_ccx(ccx, course, 'grading_policy', policy) return HttpResponse( json.dumps({ 'schedule': get_ccx_schedule(course, ccx), 'grading_policy': json.dumps(policy, indent=4)}), content_type='application/json', ) @ensure_csrf_cookie @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def set_grading_policy(request, course, ccx=None): """ Set grading policy for the CCX. """ if not ccx: raise Http404 override_field_for_ccx( ccx, course, 'grading_policy', json.loads(request.POST['policy'])) url = reverse( 'ccx_coach_dashboard', kwargs={'course_id': CCXLocator.from_course_locator(course.id, ccx.id)} ) return redirect(url) def validate_date(year, month, day, hour, minute): """ avoid corrupting db if bad dates come in """ valid = True if year < 0: valid = False if month < 1 or month > 12: valid = False if day < 1 or day > 31: valid = False if hour < 0 or hour > 23: valid = False if minute < 0 or minute > 59: valid = False return valid def parse_date(datestring): """ Generate a UTC datetime.datetime object from a string of the form 'YYYY-MM-DD HH:MM'. If string is empty or `None`, returns `None`. """ if datestring: date, time = datestring.split(' ') year, month, day = map(int, date.split('-')) hour, minute = map(int, time.split(':')) if validate_date(year, month, day, hour, minute): return datetime.datetime( year, month, day, hour, minute, tzinfo=pytz.UTC) return None def get_ccx_for_coach(course, coach): """ Looks to see if user is coach of a CCX for this course. Returns the CCX or None. """ ccxs = CustomCourseForEdX.objects.filter( course_id=course.id, coach=coach ) # XXX: In the future, it would be nice to support more than one ccx per # coach per course. This is a place where that might happen. if ccxs.exists(): return ccxs[0] return None def get_ccx_schedule(course, ccx): """ Generate a JSON serializable CCX schedule. """ def visit(node, depth=1): """ Recursive generator function which yields CCX schedule nodes. We convert dates to string to get them ready for use by the js date widgets, which use text inputs. """ for child in node.get_children(): start = get_override_for_ccx(ccx, child, 'start', None) if start: start = str(start)[:-9] due = get_override_for_ccx(ccx, child, 'due', None) if due: due = str(due)[:-9] hidden = get_override_for_ccx( ccx, child, 'visible_to_staff_only', child.visible_to_staff_only) visited = { 'location': str(child.location), 'display_name': child.display_name, 'category': child.category, 'start': start, 'due': due, 'hidden': hidden, } if depth < 3: children = tuple(visit(child, depth + 1)) if children: visited['children'] = children yield visited else: yield visited with disable_overrides(): return tuple(visit(course)) @ensure_csrf_cookie @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def ccx_schedule(request, course, ccx=None): # pylint: disable=unused-argument """ get json representation of ccx schedule """ if not ccx: raise Http404 schedule = get_ccx_schedule(course, ccx) json_schedule = json.dumps(schedule, indent=4) return HttpResponse(json_schedule, mimetype='application/json') @ensure_csrf_cookie @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def ccx_invite(request, course, ccx=None): """ Invite users to new ccx """ if not ccx: raise Http404 action = request.POST.get('enrollment-button') identifiers_raw = request.POST.get('student-ids') identifiers = _split_input_list(identifiers_raw) auto_enroll = True if 'auto-enroll' in request.POST else False email_students = True if 'email-students' in request.POST else False for identifier in identifiers: user = None email = None try: user = get_student_from_identifier(identifier) except User.DoesNotExist: email = identifier else: email = user.email try: validate_email(email) if action == 'Enroll': enroll_email( ccx, email, auto_enroll=auto_enroll, email_students=email_students ) if action == "Unenroll": unenroll_email(ccx, email, email_students=email_students) except ValidationError: log.info('Invalid user name or email when trying to invite students: %s', email) url = reverse( 'ccx_coach_dashboard', kwargs={'course_id': CCXLocator.from_course_locator(course.id, ccx.id)} ) return redirect(url) @ensure_csrf_cookie @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def ccx_student_management(request, course, ccx=None): """Manage the enrollment of individual students in a CCX """ if not ccx: raise Http404 action = request.POST.get('student-action', None) student_id = request.POST.get('student-id', '') user = email = None try: user = get_student_from_identifier(student_id) except User.DoesNotExist: email = student_id else: email = user.email try: validate_email(email) if action == 'add': # by decree, no emails sent to students added this way # by decree, any students added this way are auto_enrolled enroll_email(ccx, email, auto_enroll=True, email_students=False) elif action == 'revoke': unenroll_email(ccx, email, email_students=False) except ValidationError: log.info('Invalid user name or email when trying to enroll student: %s', email) url = reverse( 'ccx_coach_dashboard', kwargs={'course_id': CCXLocator.from_course_locator(course.id, ccx.id)} ) return redirect(url) @contextmanager def ccx_course(ccx_locator): """Create a context in which the course identified by course_locator exists """ course = get_course_by_id(ccx_locator) yield course def prep_course_for_grading(course, request): """Set up course module for overrides to function properly""" field_data_cache = FieldDataCache.cache_for_descriptor_descendents( course.id, request.user, course, depth=2) course = get_module_for_descriptor( request.user, request, course, field_data_cache, course.id, course=course ) course._field_data_cache = {} # pylint: disable=protected-access course.set_grading_policy(course.grading_policy) @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def ccx_gradebook(request, course, ccx=None): """ Show the gradebook for this CCX. """ if not ccx: raise Http404 ccx_key = CCXLocator.from_course_locator(course.id, ccx.id) with ccx_course(ccx_key) as course: prep_course_for_grading(course, request) enrolled_students = User.objects.filter( ccxmembership__ccx=ccx, ccxmembership__active=1 ).order_by('username').select_related("profile") student_info = [ { 'username': student.username, 'id': student.id, 'email': student.email, 'grade_summary': student_grades(student, request, course), 'realname': student.profile.name, } for student in enrolled_students ] return render_to_response('courseware/gradebook.html', { 'students': student_info, 'course': course, 'course_id': course.id, 'staff_access': request.user.is_staff, 'ordered_grades': sorted( course.grade_cutoffs.items(), key=lambda i: i[1], reverse=True), }) @cache_control(no_cache=True, no_store=True, must_revalidate=True) @coach_dashboard def ccx_grades_csv(request, course, ccx=None): """ Download grades as CSV. """ if not ccx: raise Http404 ccx_key = CCXLocator.from_course_locator(course.id, ccx.id) with ccx_course(ccx_key) as course: prep_course_for_grading(course, request) enrolled_students = User.objects.filter( ccxmembership__ccx=ccx, ccxmembership__active=1 ).order_by('username').select_related("profile") grades = iterate_grades_for(course, enrolled_students) header = None rows = [] for student, gradeset, __ in grades: if gradeset: # We were able to successfully grade this student for this # course. if not header: # Encode the header row in utf-8 encoding in case there are # unicode characters header = [section['label'].encode('utf-8') for section in gradeset[u'section_breakdown']] rows.append(["id", "email", "username", "grade"] + header) percents = { section['label']: section.get('percent', 0.0) for section in gradeset[u'section_breakdown'] if 'label' in section } row_percents = [percents.get(label, 0.0) for label in header] rows.append([student.id, student.email, student.username, gradeset['percent']] + row_percents) buf = StringIO() writer = csv.writer(buf) for row in rows: writer.writerow(row) return HttpResponse(buf.getvalue(), content_type='text/plain')

agpl-3.0

alchemistry/alchemlyb

src/alchemlyb/tests/test_ti_estimators.py

1

6592

"""Tests for all TI-based estimators in ``alchemlyb``. """ import pytest import pandas as pd import alchemlyb from alchemlyb.parsing import gmx, amber, gomc from alchemlyb.estimators import TI import alchemtest.gmx import alchemtest.amber import alchemtest.gomc from alchemtest.gmx import load_benzene from alchemlyb.parsing.gmx import extract_dHdl def gmx_benzene_coul_dHdl(): dataset = alchemtest.gmx.load_benzene() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['Coulomb']]) return dHdl def gmx_benzene_vdw_dHdl(): dataset = alchemtest.gmx.load_benzene() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['VDW']]) return dHdl def gmx_expanded_ensemble_case_1_dHdl(): dataset = alchemtest.gmx.load_expanded_ensemble_case_1() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['AllStates']]) return dHdl def gmx_expanded_ensemble_case_2_dHdl(): dataset = alchemtest.gmx.load_expanded_ensemble_case_2() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['AllStates']]) return dHdl def gmx_expanded_ensemble_case_3_dHdl(): dataset = alchemtest.gmx.load_expanded_ensemble_case_3() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['AllStates']]) return dHdl def gmx_water_particle_with_total_energy_dHdl(): dataset = alchemtest.gmx.load_water_particle_with_total_energy() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['AllStates']]) return dHdl def gmx_water_particle_with_potential_energy_dHdl(): dataset = alchemtest.gmx.load_water_particle_with_potential_energy() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['AllStates']]) return dHdl def gmx_water_particle_without_energy_dHdl(): dataset = alchemtest.gmx.load_water_particle_without_energy() dHdl = alchemlyb.concat([gmx.extract_dHdl(filename, T=300) for filename in dataset['data']['AllStates']]) return dHdl def amber_simplesolvated_charge_dHdl(): dataset = alchemtest.amber.load_simplesolvated() dHdl = alchemlyb.concat([amber.extract_dHdl(filename, T=300) for filename in dataset['data']['charge']]) return dHdl def amber_simplesolvated_vdw_dHdl(): dataset = alchemtest.amber.load_simplesolvated() dHdl = alchemlyb.concat([amber.extract_dHdl(filename, T=300) for filename in dataset['data']['vdw']]) return dHdl def gomc_benzene_dHdl(): dataset = alchemtest.gomc.load_benzene() dHdl = alchemlyb.concat([gomc.extract_dHdl(filename, T=298) for filename in dataset['data']]) return dHdl class TIestimatorMixin: def test_get_delta_f(self, X_delta_f): dHdl, E, dE = X_delta_f est = self.cls().fit(dHdl) delta_f = est.delta_f_.iloc[0, -1] d_delta_f = est.d_delta_f_.iloc[0, -1] assert E == pytest.approx(delta_f, rel=1e-3) assert dE == pytest.approx(d_delta_f, rel=1e-3) class TestTI(TIestimatorMixin): """Tests for TI. """ cls = TI T = 300 kT_amber = amber.k_b * T @pytest.fixture(scope="class", params = [(gmx_benzene_coul_dHdl, 3.089, 0.02157), (gmx_benzene_vdw_dHdl, -3.056, 0.04863), (gmx_expanded_ensemble_case_1_dHdl, 76.220, 0.15568), (gmx_expanded_ensemble_case_2_dHdl, 76.247, 0.15889), (gmx_expanded_ensemble_case_3_dHdl, 76.387, 0.12532), (gmx_water_particle_with_total_energy_dHdl, -11.696, 0.091775), (gmx_water_particle_with_potential_energy_dHdl, -11.751, 0.091149), (gmx_water_particle_without_energy_dHdl, -11.687, 0.091604), (amber_simplesolvated_charge_dHdl, -60.114/kT_amber, 0.08186/kT_amber), (amber_simplesolvated_vdw_dHdl, 3.824/kT_amber, 0.13254/kT_amber), ]) def X_delta_f(self, request): get_dHdl, E, dE = request.param return get_dHdl(), E, dE def test_TI_separate_dhdl_multiple_column(): dHdl = gomc_benzene_dHdl() estimator = TI().fit(dHdl) assert all([isinstance(dhdl, pd.Series) for dhdl in estimator.separate_dhdl()]) assert sorted([len(dhdl) for dhdl in estimator.separate_dhdl()]) == [8, 16] def test_TI_separate_dhdl_single_column(): dHdl = gmx_benzene_coul_dHdl() estimator = TI().fit(dHdl) assert all([isinstance(dhdl, pd.Series) for dhdl in estimator.separate_dhdl()]) assert [len(dhdl) for dhdl in estimator.separate_dhdl()] == [5, ] def test_TI_separate_dhdl_no_pertubed(): '''The test for the case where two lambda are there and one is not pertubed''' dHdl = gmx_benzene_coul_dHdl() dHdl.insert(1, 'bound-lambda', [1.0, ] * len(dHdl)) dHdl.insert(1, 'bound', [1.0, ] * len(dHdl)) dHdl.set_index('bound-lambda', append=True, inplace=True) estimator = TI().fit(dHdl) assert all([isinstance(dhdl, pd.Series) for dhdl in estimator.separate_dhdl()]) assert [len(dhdl) for dhdl in estimator.separate_dhdl()] == [5, ] class Test_Units(): '''Test the units.''' @staticmethod @pytest.fixture(scope='class') def dhdl(): bz = load_benzene().data dHdl_coul = alchemlyb.concat( [extract_dHdl(xvg, T=300) for xvg in bz['Coulomb']]) dHdl_coul.attrs = extract_dHdl(load_benzene().data['Coulomb'][0], T=300).attrs return dHdl_coul def test_ti(self, dhdl): ti = TI().fit(dhdl) assert ti.delta_f_.attrs['temperature'] == 300 assert ti.delta_f_.attrs['energy_unit'] == 'kT' assert ti.d_delta_f_.attrs['temperature'] == 300 assert ti.d_delta_f_.attrs['energy_unit'] == 'kT' assert ti.dhdl.attrs['temperature'] == 300 assert ti.dhdl.attrs['energy_unit'] == 'kT' def test_ti_separate_dhdl(self, dhdl): ti = TI().fit(dhdl) dhdl_list = ti.separate_dhdl() for dhdl in dhdl_list: assert dhdl.attrs['temperature'] == 300 assert dhdl.attrs['energy_unit'] == 'kT'

bsd-3-clause

3bot/3bot

threebot/forms.py

1

14674

from django import forms from django.forms.models import modelformset_factory from django.utils.safestring import mark_safe from organizations.models import Organization from organizations.utils import create_organization from threebot.utils import get_possible_parameters, get_possible_worker, get_curr_org from threebot.utils import get_preset_param, get_preset_worker, get_possible_owners, get_possible_lists, get_preset_list from threebot.models import Worker from threebot.models import Workflow from threebot.models import Task from threebot.models import UserParameter, OrganizationParameter, ParameterList from threebot.utils import order_workflow_tasks class UserParameterCreateForm(forms.ModelForm): next = forms.CharField(required=False, widget=forms.HiddenInput()) class Meta: model = UserParameter fields = ['data_type', 'name', 'value', 'owner', ] widgets = { 'data_type': forms.Select(attrs={'class': 'form-control', }), 'name': forms.TextInput(attrs={'class': 'form-control', }), 'value': forms.TextInput(attrs={'class': 'form-control', }), 'owner': forms.HiddenInput(), } def __init__(self, *args, **kwargs): user = kwargs.pop('user') super(UserParameterCreateForm, self).__init__(*args, **kwargs) self.fields['owner'].initial = user class UserParameterChangeForm(UserParameterCreateForm): class Meta(UserParameterCreateForm.Meta): exclude = ('owner',) class OrganizationParameterCreateForm(forms.ModelForm): class Meta: model = OrganizationParameter fields = ['data_type', 'name', 'value', 'owner', ] widgets = { 'data_type': forms.Select(attrs={'class': 'form-control', }), 'name': forms.TextInput(attrs={'class': 'form-control', }), 'value': forms.TextInput(attrs={'class': 'form-control', }), 'owner': forms.HiddenInput(), } def __init__(self, *args, **kwargs): org = kwargs.pop('org') super(OrganizationParameterCreateForm, self).__init__(*args, **kwargs) self.fields['owner'].initial = org class OrganizationParameterChangeForm(OrganizationParameterCreateForm): class Meta(OrganizationParameterCreateForm.Meta): exclude = ('owner',) def make_organization_parameter_formset(org, extra=3): """ This is a workaround for passing custom parameters (the parameter owner in our case) to a ModelFormset and is based on this stackoverflow answer: http://stackoverflow.com/a/1376616 """ class _OrganizationParameterCreateForm(forms.ModelForm): remove_from_list = forms.BooleanField(required=False) class Meta: model = OrganizationParameter fields = ['data_type', 'name', 'value', 'owner', ] widgets = { 'data_type': forms.Select(attrs={'class': 'form-control', }), 'name': forms.TextInput(attrs={'class': 'form-control', }), 'value': forms.TextInput(attrs={'class': 'form-control', }), 'owner': forms.HiddenInput(), } def __init__(self, *args, **kwargs): # self.org = org super(_OrganizationParameterCreateForm, self).__init__(*args, **kwargs) self.fields['owner'].initial = org return modelformset_factory(OrganizationParameter, form=_OrganizationParameterCreateForm, extra=extra, can_delete=True) def make_user_parameter_formset(user, extra=3): """ This is a workaround for passing custom parameters (the parameter owner in our case) to a ModelFormset and is based on this stackoverflow answer: http://stackoverflow.com/a/1376616 """ class _UserParameterCreateForm(forms.ModelForm): class Meta: model = UserParameter fields = ['data_type', 'name', 'value', 'owner', ] widgets = { 'data_type': forms.Select(attrs={'class': 'form-control', }), 'name': forms.TextInput(attrs={'class': 'form-control', }), 'value': forms.TextInput(attrs={'class': 'form-control', }), 'owner': forms.HiddenInput(), } def __init__(self, *args, **kwargs): # user = kwargs.pop('user') super(_UserParameterCreateForm, self).__init__(*args, **kwargs) self.fields['owner'].initial = user return modelformset_factory(UserParameter, form=_UserParameterCreateForm, extra=extra, can_delete=True) class ParameterListSelectForm(forms.Form): def __init__(self, *args, **kwargs): request = kwargs.pop('request') workflow = kwargs.pop('workflow') self.workflow = workflow super(ParameterListSelectForm, self).__init__(*args, **kwargs) possible_lists = [('', '--Choose a Parameter List--')] possible_lists += get_possible_lists(request, workflow) preset_list_id = get_preset_list(request, workflow, id=True) self.fields['parameter_list'] = forms.ChoiceField( label="Parameter List", choices=possible_lists, initial=preset_list_id, widget=forms.Select(attrs={'class': 'form-control', }), ) self.fields['parameter_list'].empty_label = None def clean_parameter_list(self, *args, **kwargs): list_id = self.cleaned_data['parameter_list'] parameter_list = ParameterList.objects.get(id=list_id) workflow_tasks = order_workflow_tasks(self.workflow) # make a list of ::all_required_inputs, with name and data type all_required_inputs = [] for wf_task in workflow_tasks: for name, data_type in wf_task.task.required_inputs.iteritems(): if name not in all_required_inputs: all_required_inputs.append((name, data_type)) # make a list of ::all_parameters from the list, with name and data type all_parameters = [] for parameter in parameter_list.parameters.all(): all_parameters.append((parameter.name, parameter.data_type)) # if not every element of ::all_parameters is also in ::all_required_inputs # the list is not valid for this workflow, raise an form validation error if not False not in [e in all_parameters for e in all_required_inputs]: error_message = "Not all required inputs found in ParameterList." error_message += "<br><br><strong>Required inputs by the Tasks are</strong>:" for param in all_required_inputs: error_message += "<br>" + str(param[0]) + ":" + str(param[1]) error_message += "<br><br><strong>List contains</strong>:" for param in all_parameters: error_message += "<br>" + str(param[0]) + ":" + str(param[1]) raise forms.ValidationError(mark_safe(error_message)) return list_id class WorkerSelectForm(forms.Form): def __init__(self, *args, **kwargs): request = kwargs.pop('request') workflow = kwargs.pop('workflow') super(WorkerSelectForm, self).__init__(*args, **kwargs) possible_workers = get_possible_worker(request, as_list=True) preset_worker = get_preset_worker(request, workflow, flat=True) self.fields['worker'] = forms.MultipleChoiceField( required=True, label="Worker", choices=possible_workers, initial=preset_worker, widget=forms.SelectMultiple(attrs={'class': 'form-control', }), ) self.fields['worker'].empty_label = None # workaround for displaying a message to the user # if no worker is acessible while initializing the form if len(possible_workers) <= 0: self.cleaned_data = {} msg = "No Worker found. Please configure a Worker first." self.add_error('worker', msg) def clean(self): cleaned_data = super(WorkerSelectForm, self).clean() worker_ids = cleaned_data.get('worker', []) workers = Worker.objects.filter(id__in=worker_ids) for worker in workers: if not worker.is_accessible: raise forms.ValidationError("worker not accessible") # Always return the full collection of cleaned data. # This has changed in django 1.7 but raises errors in django <1.7 # We want to support both, so we return cleanded_data return cleaned_data class WorkerForm(forms.ModelForm): """Base Worker Form""" class Meta: model = Worker fields = ['title', 'ip', 'port', 'muted', 'secret_key', 'pre_task', 'post_task', ] widgets = { 'title': forms.TextInput(attrs={'class': 'form-control', }), 'ip': forms.TextInput(attrs={'class': 'form-control', }), 'addr': forms.TextInput(attrs={'class': 'form-control', 'rows': '5', }), 'port': forms.TextInput(attrs={'class': 'form-control', }), 'secret_key': forms.TextInput(attrs={'class': 'form-control', }), 'pre_task': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', }), 'post_task': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', }), } def __init__(self, *args, **kwargs): super(WorkerForm, self).__init__(*args, **kwargs) class WorkerCreateForm(WorkerForm): """Form to create a Worker""" class Meta(WorkerForm.Meta): fields = ['owner', ] + WorkerForm.Meta.fields exclude = ['muted'] WorkerForm.Meta.widgets['owner'] = forms.Select(attrs={'class': 'form-control'}) def __init__(self, *args, **kwargs): request = kwargs.pop('request') super(WorkerCreateForm, self).__init__(*args, **kwargs) self.fields['owner'].queryset = get_possible_owners(request) self.fields['owner'].initial = get_curr_org(request) class WorkerChangeForm(WorkerForm): """Form to edit a Worker""" pass class TaskForm(forms.ModelForm): """Base Task Form""" class Meta: model = Task fields = ['title', 'desc', 'template', 'changelog', 'is_readonly', ] widgets = { 'title': forms.TextInput(attrs={'class': 'form-control', }), 'desc': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', }), 'template': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', 'style': 'font-family:monospace;'}), 'changelog': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', }), 'is_readonly': forms.CheckboxInput(attrs={}), } def __init__(self, *args, **kwargs): super(TaskForm, self).__init__(*args, **kwargs) class TaskCreateForm(TaskForm): """Form to create a Task""" class Meta(TaskForm.Meta): fields = ['owner', ] + TaskForm.Meta.fields TaskForm.Meta.widgets['owner'] = forms.Select(attrs={'class': 'form-control'}) def __init__(self, *args, **kwargs): request = kwargs.pop('request') super(TaskCreateForm, self).__init__(*args, **kwargs) self.fields['owner'].queryset = get_possible_owners(request) self.fields['owner'].initial = get_curr_org(request) class TaskChangeForm(TaskForm): """Form to edit a Task""" pass class TaskImportForm(forms.Form): """Form to import a Task""" task_json = forms.FileField() class WorkflowForm(forms.ModelForm): """Base Workflow Form""" class Meta: model = Workflow fields = ['title', 'desc', 'pre_task', 'post_task', ] widgets = { 'title': forms.TextInput(attrs={'class': 'form-control', }), 'desc': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', }), 'pre_task': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', }), 'post_task': forms.Textarea(attrs={'class': 'form-control', 'rows': '5', }), } def __init__(self, *args, **kwargs): super(WorkflowForm, self).__init__(*args, **kwargs) class WorkflowCreateForm(WorkflowForm): """Form to create a Workflow""" class Meta(WorkflowForm.Meta): fields = ['owner', ] + WorkflowForm.Meta.fields WorkflowForm.Meta.widgets['owner'] = forms.Select(attrs={'class': 'form-control'}) def __init__(self, *args, **kwargs): request = kwargs.pop('request') super(WorkflowCreateForm, self).__init__(*args, **kwargs) self.fields['owner'].queryset = get_possible_owners(request) self.fields['owner'].initial = get_curr_org(request) class WorkflowChangeForm(WorkflowForm): """Form to edit a Workflow""" pass class WorkflowReorderForm(forms.Form): workflow_id = forms.CharField(max_length=30, widget=forms.HiddenInput()) order = forms.CharField(widget=forms.HiddenInput()) class TaskParameterForm(forms.Form): def __init__(self, *args, **kwargs): request = kwargs.pop('request') extra = kwargs.pop('extra') workflow_task = kwargs.pop('workflow_task') super(TaskParameterForm, self).__init__(*args, **kwargs) for name, data_type in extra.iteritems(): possible_parameters = get_possible_parameters(request, workflow_task, data_type) preset_parameter = get_preset_param(request, workflow_task, name, data_type) self.fields['wt_task_%i.%s.%s' % (workflow_task.id, data_type, name)] = forms.ChoiceField( label="%s (%s)" % (name, data_type), choices=possible_parameters, initial=preset_parameter, widget=forms.Select(attrs={'class': 'form-control', }), ) # each param gets a hidden field for saving prompted data self.fields['prompt_wt_task_%i.%s.%s' % (workflow_task.id, data_type, name)] = forms.CharField(widget=forms.HiddenInput(), required=False, ) class OrganizationCreateForm(forms.ModelForm): """ Form class for creating a new organization, complete with new owner, including a User instance, OrganizationUser instance, and OrganizationOwner instance. """ def __init__(self, *args, **kwargs): self.request = kwargs.pop('request') super(OrganizationCreateForm, self).__init__(*args, **kwargs) class Meta: model = Organization exclude = ('users', 'is_active',) def save(self, **kwargs): """ Create the organization, then get the user, then make the owner. """ user = self.request.user return create_organization(user, self.cleaned_data['name'], self.cleaned_data['slug'], is_active=True)

bsd-3-clause

Intel-tensorflow/tensorflow

tensorflow/compiler/mlir/tensorflow/tests/tf_saved_model/basic_v1_no_variable_lifting.py

6

2020

# Copyright 2021 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. # ============================================================================== # RUN: %p/basic_v1_no_variable_lifting | FileCheck %s # pylint: disable=missing-docstring,line-too-long from __future__ import absolute_import from __future__ import division from __future__ import print_function import tensorflow.compat.v1 as tf from tensorflow.compiler.mlir.tensorflow.tests.tf_saved_model import common_v1 # Verify that the tf.versions attribute exists. It is difficult to enforce # contents, since the version numbers change over time. The conversion logic # itself is verified in the common graphdef converter, so here just assert # it is being invoked. # CHECK: module # CHECK-NOT: tf_saved_model.global_tensor def Test(): x = tf.constant([[1.0], [1.0], [1.0]]) y = tf.compat.v1.get_variable( name='y', shape=(1, 3), initializer=tf.random_normal_initializer(), trainable=True) r = tf.matmul(x, y) tensor_info_x = tf.compat.v1.saved_model.utils.build_tensor_info(x) tensor_info_r = tf.compat.v1.saved_model.utils.build_tensor_info(r) return { 'key': (tf.compat.v1.saved_model.signature_def_utils.build_signature_def( inputs={'x': tensor_info_x}, outputs={'r': tensor_info_r}, method_name='some_function')) }, None, None if __name__ == '__main__': common_v1.set_tf_options() common_v1.do_test(Test, lift_variables=False)

apache-2.0

krafczyk/spack

var/spack/repos/builtin/packages/icet/package.py

2

2017

############################################################################## # Copyright (c) 2013-2018, Lawrence Livermore National Security, LLC. # Produced at the Lawrence Livermore National Laboratory. # # This file is part of Spack. # Created by Todd Gamblin, tgamblin@llnl.gov, All rights reserved. # LLNL-CODE-647188 # # For details, see https://github.com/spack/spack # Please also see the NOTICE and LICENSE files for our notice and the LGPL. # # This program 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) version 2.1, February 1999. # # This program 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 terms and # conditions of the GNU Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ############################################################################## from spack import * class Icet(CMakePackage): """The Image Composition Engine for Tiles (IceT) is a high-performance sort-last parallel rendering library.""" homepage = "http://icet.sandia.gov" url = "https://gitlab.kitware.com/api/v4/projects/icet%2Ficet/repository/archive.tar.bz2?sha=IceT-2.1.1" git = "https://gitlab.kitware.com/icet/icet.git" version('develop', branch='master') version('2.1.1', '4f971c51105a64937460d482adca2a6c') depends_on('mpi') def cmake_args(self): return ['-DICET_USE_OPENGL:BOOL=OFF'] def setup_dependent_environment(self, spack_env, run_env, dependent_spec): """Work-around for ill-placed CMake modules""" spack_env.prepend_path('CMAKE_PREFIX_PATH', self.prefix.lib)

lgpl-2.1

joshrabinowitz/bitcoin

test/functional/p2p_timeouts.py

3

2305

#!/usr/bin/env python3 # Copyright (c) 2016-2017 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. """Test various net timeouts. - Create three bitcoind nodes: no_verack_node - we never send a verack in response to their version no_version_node - we never send a version (only a ping) no_send_node - we never send any P2P message. - Start all three nodes - Wait 1 second - Assert that we're connected - Send a ping to no_verack_node and no_version_node - Wait 30 seconds - Assert that we're still connected - Send a ping to no_verack_node and no_version_node - Wait 31 seconds - Assert that we're no longer connected (timeout to receive version/verack is 60 seconds) """ from time import sleep from test_framework.mininode import * from test_framework.test_framework import BitcoinTestFramework from test_framework.util import * class TestP2PConn(P2PInterface): def on_version(self, message): # Don't send a verack in response pass class TimeoutsTest(BitcoinTestFramework): def set_test_params(self): self.setup_clean_chain = True self.num_nodes = 1 def run_test(self): # Setup the p2p connections no_verack_node = self.nodes[0].add_p2p_connection(TestP2PConn()) no_version_node = self.nodes[0].add_p2p_connection(TestP2PConn(), send_version=False) no_send_node = self.nodes[0].add_p2p_connection(TestP2PConn(), send_version=False) sleep(1) assert no_verack_node.is_connected assert no_version_node.is_connected assert no_send_node.is_connected no_verack_node.send_message(msg_ping()) no_version_node.send_message(msg_ping()) sleep(30) assert "version" in no_verack_node.last_message assert no_verack_node.is_connected assert no_version_node.is_connected assert no_send_node.is_connected no_verack_node.send_message(msg_ping()) no_version_node.send_message(msg_ping()) sleep(31) assert not no_verack_node.is_connected assert not no_version_node.is_connected assert not no_send_node.is_connected if __name__ == '__main__': TimeoutsTest().main()

mit

inkerra/cinder

cinder/openstack/common/processutils.py

2

9178

# vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2011 OpenStack Foundation. # 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. """ System-level utilities and helper functions. """ import os import random import shlex import signal from eventlet.green import subprocess from eventlet import greenthread from cinder.openstack.common.gettextutils import _ from cinder.openstack.common import log as logging LOG = logging.getLogger(__name__) class InvalidArgumentError(Exception): def __init__(self, message=None): super(InvalidArgumentError, self).__init__(message) class UnknownArgumentError(Exception): def __init__(self, message=None): super(UnknownArgumentError, self).__init__(message) class ProcessExecutionError(Exception): def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None, description=None): self.exit_code = exit_code self.stderr = stderr self.stdout = stdout self.cmd = cmd self.description = description if description is None: description = "Unexpected error while running command." if exit_code is None: exit_code = '-' message = ("%s\nCommand: %s\nExit code: %s\nStdout: %r\nStderr: %r" % (description, cmd, exit_code, stdout, stderr)) super(ProcessExecutionError, self).__init__(message) class NoRootWrapSpecified(Exception): def __init__(self, message=None): super(NoRootWrapSpecified, self).__init__(message) def _subprocess_setup(): # Python installs a SIGPIPE handler by default. This is usually not what # non-Python subprocesses expect. signal.signal(signal.SIGPIPE, signal.SIG_DFL) def execute(*cmd, **kwargs): """Helper method to shell out and execute a command through subprocess. Allows optional retry. :param cmd: Passed to subprocess.Popen. :type cmd: string :param process_input: Send to opened process. :type proces_input: string :param check_exit_code: Single bool, int, or list of allowed exit codes. Defaults to [0]. Raise :class:`ProcessExecutionError` unless program exits with one of these code. :type check_exit_code: boolean, int, or [int] :param delay_on_retry: True | False. Defaults to True. If set to True, wait a short amount of time before retrying. :type delay_on_retry: boolean :param attempts: How many times to retry cmd. :type attempts: int :param run_as_root: True | False. Defaults to False. If set to True, the command is prefixed by the command specified in the root_helper kwarg. :type run_as_root: boolean :param root_helper: command to prefix to commands called with run_as_root=True :type root_helper: string :param shell: whether or not there should be a shell used to execute this command. Defaults to false. :type shell: boolean :returns: (stdout, stderr) from process execution :raises: :class:`UnknownArgumentError` on receiving unknown arguments :raises: :class:`ProcessExecutionError` """ process_input = kwargs.pop('process_input', None) check_exit_code = kwargs.pop('check_exit_code', [0]) ignore_exit_code = False delay_on_retry = kwargs.pop('delay_on_retry', True) attempts = kwargs.pop('attempts', 1) run_as_root = kwargs.pop('run_as_root', False) root_helper = kwargs.pop('root_helper', '') shell = kwargs.pop('shell', False) if isinstance(check_exit_code, bool): ignore_exit_code = not check_exit_code check_exit_code = [0] elif isinstance(check_exit_code, int): check_exit_code = [check_exit_code] if kwargs: raise UnknownArgumentError(_('Got unknown keyword args ' 'to utils.execute: %r') % kwargs) if run_as_root and os.geteuid() != 0: if not root_helper: raise NoRootWrapSpecified( message=('Command requested root, but did not specify a root ' 'helper.')) cmd = shlex.split(root_helper) + list(cmd) cmd = map(str, cmd) while attempts > 0: attempts -= 1 try: LOG.debug(_('Running cmd (subprocess): %s'), ' '.join(cmd)) _PIPE = subprocess.PIPE # pylint: disable=E1101 if os.name == 'nt': preexec_fn = None close_fds = False else: preexec_fn = _subprocess_setup close_fds = True obj = subprocess.Popen(cmd, stdin=_PIPE, stdout=_PIPE, stderr=_PIPE, close_fds=close_fds, preexec_fn=preexec_fn, shell=shell) result = None if process_input is not None: result = obj.communicate(process_input) else: result = obj.communicate() obj.stdin.close() # pylint: disable=E1101 _returncode = obj.returncode # pylint: disable=E1101 if _returncode: LOG.debug(_('Result was %s') % _returncode) if not ignore_exit_code and _returncode not in check_exit_code: (stdout, stderr) = result raise ProcessExecutionError(exit_code=_returncode, stdout=stdout, stderr=stderr, cmd=' '.join(cmd)) return result except ProcessExecutionError: if not attempts: raise else: LOG.debug(_('%r failed. Retrying.'), cmd) if delay_on_retry: greenthread.sleep(random.randint(20, 200) / 100.0) finally: # NOTE(termie): this appears to be necessary to let the subprocess # call clean something up in between calls, without # it two execute calls in a row hangs the second one greenthread.sleep(0) def trycmd(*args, **kwargs): """A wrapper around execute() to more easily handle warnings and errors. Returns an (out, err) tuple of strings containing the output of the command's stdout and stderr. If 'err' is not empty then the command can be considered to have failed. :discard_warnings True | False. Defaults to False. If set to True, then for succeeding commands, stderr is cleared """ discard_warnings = kwargs.pop('discard_warnings', False) try: out, err = execute(*args, **kwargs) failed = False except ProcessExecutionError as exn: out, err = '', str(exn) failed = True if not failed and discard_warnings and err: # Handle commands that output to stderr but otherwise succeed err = '' return out, err def ssh_execute(ssh, cmd, process_input=None, addl_env=None, check_exit_code=True): LOG.debug(_('Running cmd (SSH): %s'), cmd) if addl_env: raise InvalidArgumentError(_('Environment not supported over SSH')) if process_input: # This is (probably) fixable if we need it... raise InvalidArgumentError(_('process_input not supported over SSH')) stdin_stream, stdout_stream, stderr_stream = ssh.exec_command(cmd) channel = stdout_stream.channel # NOTE(justinsb): This seems suspicious... # ...other SSH clients have buffering issues with this approach stdout = stdout_stream.read() stderr = stderr_stream.read() stdin_stream.close() exit_status = channel.recv_exit_status() # exit_status == -1 if no exit code was returned if exit_status != -1: LOG.debug(_('Result was %s') % exit_status) if check_exit_code and exit_status != 0: raise ProcessExecutionError(exit_code=exit_status, stdout=stdout, stderr=stderr, cmd=cmd) return (stdout, stderr)

apache-2.0

gunnarleffler/instapost

tdg_or_wa_avgs/cwms_read.py

1

8073

# -*- coding: utf-8 -*- import requests import json import pandas as pd from datetime import datetime, timedelta def reindex(df, start_date, end_date, freq): date = pd.date_range(start = datetime(*start_date), end = datetime(*end_date), freq = freq) date = [pd.Timestamp(x) for x in date] df = df.reindex(date) df.index.rename('date', inplace = True) return df def get_frequency(index): """ Args: index: a pd.core.indexes.datetimes.DatetimeIndex from a timeseries Returns: freq: a string value of either a daily, hourly, minutely, or secondly Offset Alias with the appropriate multiple. This is not very robust, and returns False if it is not able to easily determine the frequency """ seconds = index.to_series().diff().median().total_seconds() minutes = seconds/60 hours = minutes/60 days = hours/24 if days>=1 and days%int(days) == 0: freq = str(int(days))+'D' elif hours>=1 and hours%int(hours) == 0: freq = str(int(hours))+'H' elif minutes>=1 and minutes%int(minutes) == 0: freq = str(int(minutes))+'min' elif seconds>=1 and seconds%int(seconds) == 0: freq = str(int(seconds))+'S' else: freq = False return freq def time_window_url(paths, public=True, lookback = 7, start_date = False, end_date = False, timezone = 'PST'): """ helper function for cwms_read Arguments: path -- cwms data path, public -- boolean, start_date -- date integer tuple format (YYYY, m, d) end_date -- date integer tuple format (YYYY, m, d) timezone -- optional keyword argument if time zone is specified. Defaults to 'PST' if nothing set Returns: url -- url string of CWMS data webservice for the specified data path and time window """ if isinstance(paths, list): path = '%22%2C%22'.join(paths) else: path = paths if public: url = r'http://pweb.crohms.org/dd/common/web_service/webexec/getjson?timezone=TIMEZONE_&query=%5B%22PATH%22%5D&' else: url = r'http://nwp-wmlocal2.nwp.usace.army.mil/common/web_service/webexec/getjson?timezone=TIMEZONE_&query=%5B%22PATH%22%5D&' url = url.replace('PATH', path).replace('TIMEZONE_', timezone) if lookback: time = 'backward=' + str(lookback) + 'd' url = url + time else: url = url + 'startdate=START_MONTH%2FSTART_DAY%2FSTART_YEAR+00%3A00&enddate=END_MONTH%2FEND_DAY%2FEND_YEAR+00%3A00' sy,sm,sd = start_date start_date = datetime(sy,sm,sd) ey,em,ed = end_date end_date = datetime(ey,em,ed) url = url.replace('START_MONTH', str(start_date.month)).replace('START_DAY', str(start_date.day)).replace('START_YEAR', str(start_date.year)) url = url.replace('END_MONTH', str(end_date.month)).replace('END_DAY', str(end_date.day)).replace('END_YEAR', str(end_date.year)) return url def get_cwms(path, public = True, fill = True, **kwargs): """ A function to parse CWMS json data from webservice into a pandas dataframe Positional Arguments: paths -- single string or list of string of CWMS data paths, example: 'TDDO.Temp-Water.Inst.1Hour.0.GOES-REV' Keyword Arguments: The web service can either get a lookback, which is just a number of days from the current day, or a time window. Two key word arguments are needed for a time wondow, start_date, end_date. The Timezone can also be set. lookback -- The number of days from current day to grab data. (int or str) example: 7 start_date -- The start of a time window (tuple) formatted (year, month, day) example: (2017, 3, 22) end_date -- The end of a time window (tuple) formatted (year, month, day) example: (2017, 3, 22) timezone -- "PST", "PDT", "MST", "MDT", "GMT" Returns: df -- A pandas dataframe with metadata from the webservice is returned. Metadata is stored in df.__dict__['metadata'], the data is used in some of the plotting functions. The metadata is easily lost if a df is copied or transformed in some way. It may be best to export the metadata if it is needed. meta = df.__dict__['metadata'] """ try: lookback = kwargs['lookback'] start_date = False end_date = False except: lookback = False start_date = kwargs['start_date'] end_date = kwargs['end_date'] try:timezone = kwargs['timezone'] except: timezone = 'PST' url = time_window_url(path,start_date=start_date, end_date=end_date, lookback = lookback, public=public,timezone = timezone) r = requests.get(url) json_data = json.loads(r.text) df_list = [] meta = {} if not isinstance(path, list): path = [path] for site in path: s = site.split('.')[0] try: data = json_data[s] except KeyError: print('No data for %s' % site) continue lat = data['coordinates']['latitude'] long = data['coordinates']['longitude'] tz_offset = data['tz_offset'] tz = data['timezone'] for path, vals in data['timeseries'].items(): column_name = '_'.join(path.split('.')[:2]) column_name = '_'.join(column_name.split('-')) try:path_data = vals['values'] except KeyError: print('No data for %s' % site) continue date = [val[0] for val in path_data] values = [val[1] for val in path_data] df= pd.DataFrame({'date': date, column_name: values}) df['date'] = pd.to_datetime(df['date']) df.set_index('date', inplace = True) df_list.append(df) vals.pop('values', None) vals.update({'path':path, 'lat':lat,'long':long, 'tz_offset':tz_offset, 'timezone':tz}) meta.update({column_name:vals}) df = pd.concat(df_list, axis = 1) if fill: freq = get_frequency(df.index) if not freq: print('Unable to determine frequency, returning data frame unfilled') else: if lookback: end = datetime.now() start = end - timedelta(days=lookback) start_date = (start.year,start.month,start.day) end_date = (end.year,end.month,end.day) df = df.pipe(reindex, start_date, end_date, freq) df.__dict__['metadata'] = meta return df def catalog(): """ Requests the CWMS catalog. Returns a large dict and not easy wade through, it would be easier to go to a dataquery site to find what you are looking for http://www.nwd-wc.usace.army.mil/dd/common/dataquery/www/ Arguments: Returns: dict """ url = r'http://www.nwd-wc.usace.army.mil/dd/common/web_service/webexec/getjson?catalog=%5B%5D' r = requests.get(url) return json.loads(r.text) def site_catalog(site): """ Returns a dictionary of CWMS data paths for a particular site Arguments: site -- cwms site name, example TDDO Returns: json.loads(r.text) -- dictionary of available site data """ url = r'http://www.nwd-wc.usace.army.mil/dd/common/web_service/webexec/getjson?tscatalog=%5B%22SITE%22%5D' url = url.replace('SITE', site.upper()) r = requests.get(url) return json.loads(r.text)

mit

codefisher/codefisher_apps

site_crawler/migrations/0001_initial.py

1

1310

# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations class Migration(migrations.Migration): dependencies = [ ] operations = [ migrations.CreateModel( name='CrawledPage', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('url', models.TextField()), ('title', models.CharField(max_length=200, null=True, blank=True)), ('size', models.IntegerField()), ('status', models.IntegerField()), ('parents', models.TextField(null=True, blank=True)), ], options={ }, bases=(models.Model,), ), migrations.CreateModel( name='CrawlProcess', fields=[ ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)), ('name', models.CharField(max_length=50)), ('crawler', models.CharField(max_length=50, choices=[(b'site_crawler', b'Site Crawler')])), ('deny', models.TextField()), ], options={ }, bases=(models.Model,), ), ]

mit

bnaul/scikit-learn

sklearn/linear_model/__init__.py

12

2872

""" The :mod:`sklearn.linear_model` module implements a variety of linear models. """ # See http://scikit-learn.sourceforge.net/modules/sgd.html and # http://scikit-learn.sourceforge.net/modules/linear_model.html for # complete documentation. from ._base import LinearRegression from ._bayes import BayesianRidge, ARDRegression from ._least_angle import (Lars, LassoLars, lars_path, lars_path_gram, LarsCV, LassoLarsCV, LassoLarsIC) from ._coordinate_descent import (Lasso, ElasticNet, LassoCV, ElasticNetCV, lasso_path, enet_path, MultiTaskLasso, MultiTaskElasticNet, MultiTaskElasticNetCV, MultiTaskLassoCV) from ._glm import (PoissonRegressor, GammaRegressor, TweedieRegressor) from ._huber import HuberRegressor from ._sgd_fast import Hinge, Log, ModifiedHuber, SquaredLoss, Huber from ._stochastic_gradient import SGDClassifier, SGDRegressor from ._ridge import (Ridge, RidgeCV, RidgeClassifier, RidgeClassifierCV, ridge_regression) from ._logistic import LogisticRegression, LogisticRegressionCV from ._omp import (orthogonal_mp, orthogonal_mp_gram, OrthogonalMatchingPursuit, OrthogonalMatchingPursuitCV) from ._passive_aggressive import PassiveAggressiveClassifier from ._passive_aggressive import PassiveAggressiveRegressor from ._perceptron import Perceptron from ._ransac import RANSACRegressor from ._theil_sen import TheilSenRegressor __all__ = ['ARDRegression', 'BayesianRidge', 'ElasticNet', 'ElasticNetCV', 'Hinge', 'Huber', 'HuberRegressor', 'Lars', 'LarsCV', 'Lasso', 'LassoCV', 'LassoLars', 'LassoLarsCV', 'LassoLarsIC', 'LinearRegression', 'Log', 'LogisticRegression', 'LogisticRegressionCV', 'ModifiedHuber', 'MultiTaskElasticNet', 'MultiTaskElasticNetCV', 'MultiTaskLasso', 'MultiTaskLassoCV', 'OrthogonalMatchingPursuit', 'OrthogonalMatchingPursuitCV', 'PassiveAggressiveClassifier', 'PassiveAggressiveRegressor', 'Perceptron', 'Ridge', 'RidgeCV', 'RidgeClassifier', 'RidgeClassifierCV', 'SGDClassifier', 'SGDRegressor', 'SquaredLoss', 'TheilSenRegressor', 'enet_path', 'lars_path', 'lars_path_gram', 'lasso_path', 'orthogonal_mp', 'orthogonal_mp_gram', 'ridge_regression', 'RANSACRegressor', 'PoissonRegressor', 'GammaRegressor', 'TweedieRegressor']

bsd-3-clause

gajim/python-nbxmpp

nbxmpp/modules/eme.py

1

1740

# Copyright (C) 2018 Philipp Hörist <philipp AT hoerist.com> # # This file is part of nbxmpp. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 3 # of the License, or (at your option) any later version. # # This program 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; If not, see <http://www.gnu.org/licenses/>. from nbxmpp.namespaces import Namespace from nbxmpp.structs import StanzaHandler from nbxmpp.structs import EMEData from nbxmpp.modules.base import BaseModule class EME(BaseModule): def __init__(self, client): BaseModule.__init__(self, client) self._client = client self.handlers = [ StanzaHandler(name='message', callback=self._process_eme, ns=Namespace.EME, priority=40) ] def _process_eme(self, _client, stanza, properties): encryption = stanza.getTag('encryption', namespace=Namespace.EME) if encryption is None: return name = encryption.getAttr('name') namespace = encryption.getAttr('namespace') if namespace is None: self._log.warning('No namespace on message') return properties.eme = EMEData(name=name, namespace=namespace) self._log.info('Found data: %s', properties.eme)

gpl-3.0

alunem/bioman

fasta/bmn-FastaRandDivides.py

1

1085

#!/usr/bin/env python import string import sys import os from Bio import SeqIO from Bio.Seq import Seq from Bio.SeqRecord import SeqRecord from StringIO import StringIO import random import tempfile fastafile = sys.argv[1] #fastafile = "/bank/fasta/Roth/E1.454.fasta" randomYorN = sys.argv[2] nbPart=int(sys.argv[3]) #nbPart=int(5) seqs=[] nbSeqs=0 handle = open(fastafile) for seq_record in SeqIO.parse(handle, "fasta"): seqs.append(seq_record) nbSeqs+=1 handle.close() if randomYorN.lower()=="yes": random.shuffle(seqs) elif randomYorN.lower()!="no": print("The second argument should be yes or no. Do you want to randomize the sequences before dividing the fasta file ?") #### writes the divided-input fasta files into it nbSeqsbyfile=nbSeqs/nbPart modulo=nbSeqs%nbPart iteSeqs=0 for i in range(0,nbPart-1): handleout = open("part"+str(i+1)+"."+fastafile, "w") SeqIO.write(seqs[iteSeqs:iteSeqs+nbSeqsbyfile], handleout, "fasta") iteSeqs+=nbSeqsbyfile handleout = open("part."+str(nbPart)+"."+fastafile, "w") SeqIO.write(seqs[iteSeqs:nbSeqs], handleout, "fasta")

gpl-2.0

infinit/drake

src/drake/flex.py

1

5564

# Copyright (C) 2011-2016, Quentin "mefyl" Hocquet # # This software is provided "as is" without warranty of any kind, # either expressed or implied, including but not limited to the # implied warranties of fitness for a particular purpose. # # See the LICENSE file for more information. import drake import sys class SDK(drake.Configuration): """Configuration for the Flex SDK library.""" def __init__(self, prefix = None): """Find and create a configuration for the Flex SDK. prefix -- Where to find the Flex SDK, should contain bin/acompc. """ # Compute the search path. if prefix is None: test = [drake.Path('/usr'), drake.Path('/usr/local')] else: test = [drake.Path(prefix)] self.__prefix = self._search_all('bin/acompc', test)[0] self.__options = [] self.__external_library_path = [] def add_option(self, option): self.__options.append(option) def flags(self): def mkpath(path): if not path.absolute(): path = drake.srctree() / path return str(path) options = ''.join(map(lambda o: ' %s' % o, self.__options)) external_libraries = '' if self.__external_library_path: external_libraries = ':'.join(map(mkpath, self.__external_library_path)) external_libraries = ' -external-library-path+=%s' % external_libraries return options + external_libraries def add_external_library_path(self, path): path = drake.Path(path) self.__external_library_path.append(path) def acompc(self): return self.__prefix / 'bin/acompc' def mxmlc(self): return self.__prefix / 'bin/mxmlc' def __repr__(self): return 'Flex(prefix = %s)' % repr(self.__prefix) class Source(drake.Node): pass drake.Node.extensions['as'] = Source class Library(drake.Node): def __init__(self, name, sources, flex_sdk): self.__sources = sources self.__sdk = flex_sdk drake.Node.__init__(self, name) LibraryBuilder(sources, self, flex_sdk) drake.Node.extensions['swc'] = Library class LibraryBuilder(drake.Builder): def __init__(self, sources, target, sdk): self.__sources = list(filter(lambda s: not isinstance(s, Library), sources)) self.__libraries = list(filter(lambda s: isinstance(s, Library), sources)) self.__target = target self.__sdk = sdk drake.Builder.__init__(self, sources, [target]) def execute(self): # Options options = ' -compiler.locale -compiler.optimize -static-link-runtime-shared-libraries -compiler.debug' # Sources sources = ' '.join(map(lambda src: str(src.path()), self.__sources)) # Libraries libraries = '' if self.__libraries: libraries = ' -external-library-path+=%s' % ':'.join(map(lambda n: str(n.path().dirname()), self.__libraries)) # Output output = str(self.__target.path()) # Command return self.cmd('Flex %s' % self.__target, '%s%s %s -include-sources %s%s -output %s', str(self.__sdk.acompc()), self.__sdk.flags(), options, sources, libraries, output) # _local/flex_sdk/bin/acompc -external-library-path+=modules/bindings/flash/UObjectFlash/libs/ -compiler.locale -compiler.optimize -static-link-runtime-shared-libraries -compiler.debug -keep-as3-metadata Urbi -include-sources modules/bindings/flash/UObjectFlash/com/ -output /tmp/UObjeftFlash.swc class Application(drake.Node): def __init__(self, name, config, source_path, source, sources, flex_sdk): source_path = drake.Path(source_path) self.__config = config self.__source = source self.__source_path = source_path self.__sources = sources self.__sdk = flex_sdk drake.Node.__init__(self, name) ApplicationBuilder(sources, self, config, source, source_path, flex_sdk) drake.Node.extensions['swf'] = Application class ApplicationBuilder(drake.Builder): def __init__(self, sources, target, config, source, source_path, flex_sdk): self.__config = config self.__source_path = source_path self.__source = source self.__sources = list(filter(lambda s: not isinstance(s, Library), sources)) self.__libraries = list(filter(lambda s: isinstance(s, Library), sources)) self.__target = target self.__sdk = flex_sdk drake.Builder.__init__(self, sources + [config, source], [target]) def execute(self): # Options options = ' -compiler.locale -compiler.optimize -static-link-runtime-shared-libraries -compiler.debug' # Sources sources = ' '.join(map(lambda src: str(src.path()), self.__sources)) # Libraries libraries = '' if self.__libraries: libraries = ' -library-path+=%s' % ':'.join(map(lambda n: str(n.path().dirname()), self.__libraries)) # Output output = str(self.__target.path()) # Command return self.cmd('Flex %s' % self.__target, '%s%s -load-config %s -compiler.source-path %s -output %s %s', self.__sdk.mxmlc(), libraries, self.__config.path(), drake.srctree() / self.__source_path, self.__target.path(), self.__source.path(), ) # $PWD/_local/flex_sdk/bin/mxmlc -compiler.source-path submodules/modules/bindings/flash/FlashServer submodules/modules/bindings/flash/FlashServer/FlashServer.mxml -compiler.external-library-path+=_build/submodules/modules/bindings/flash/UObjectFlash:_build/submodules/modules/bindings/flash/UStdLib

agpl-3.0

palaniyappanBala/rekall

rekall-core/rekall/plugins/collectors/ballast.py

4

1600

# Rekall Memory Forensics # # Copyright 2014 Google Inc. All Rights Reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or (at # your option) any later version. # # This program 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 # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # """ The Rekall Memory Forensics entity layer. """ __author__ = "Adam Sindelar <adamsh@google.com>" import datetime from rekall.entities import definitions from rekall.entities import collector class BallastGenerator(collector.EntityCollector): """Generates ballast entities to stress-test the entity system.""" outputs = ["Timestamps", "Named"] @classmethod def is_active(cls, session): return session.GetParameter("generate_ballast") > 0 def collect(self, hint): for i in range(self.session.GetParameter("generate_ballast")): yield [ definitions.Named( name="Ballast entry #%d" % i, kind="Ballast"), definitions.Timestamps( created_at=datetime.datetime.fromtimestamp(0))]

gpl-2.0

edisonlz/fruit

web_project/base/site-packages/util/thrift/thrifttools.py

1

1984

#!/usr/bin/env python # -*- coding: utf-8 -*- from contextlib import contextmanager import thread import logging from thrift.transport import TSocket, TTransport from thrift.protocol import TBinaryProtocol import settings SERVICE_SELECTION = 0 class ThreadMappedPool(dict): def __new__(cls, master): return super(ThreadMappedPool, cls).__new__(cls) def __init__(self, master): self.master = master @property def current_key(self): return thread.get_ident() @contextmanager def reserve(self): """Reserve a client. Creates a new client based on the master client if none exists for the current thread. """ key = self.current_key mc = self.pop(key, None) if mc is None: mc = self.master.clone() try: yield mc finally: self[key] = mc def relinquish(self): """Relinquish any reserved client for the current context. Call this method before exiting a thread if it might potentially use this pool. """ return self.pop(self.current_key, None) # transport _trans = None def transport(reconn=False): global _trans if reconn or not (_trans and _trans.isOpen()): _trans = TSocket.TSocket(**settings.thrift_server) logging.debug("http://%s:%s" % (settings.thrift_server['host'], str(settings.thrift_server['port']))) _trans = TTransport.TBufferedTransport(_trans) _trans.open() return _trans def protocol(trans): return TBinaryProtocol.TBinaryProtocolAccelerated(trans) def service(sname, protocol): def deco(fn): def f(*args, **kwargs): protocol.writeMessageBegin(sname, SERVICE_SELECTION, 0) result = fn(*args, **kwargs) protocol.writeMessageEnd() return result return f return deco #test #service_client_map, service_iface_map = register_service_client()

apache-2.0

hyperized/ansible

lib/ansible/modules/network/f5/bigip_irule.py

38

17060

#!/usr/bin/python # -*- coding: utf-8 -*- # # Copyright: (c) 2017, F5 Networks Inc. # GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) from __future__ import absolute_import, division, print_function __metaclass__ = type ANSIBLE_METADATA = {'metadata_version': '1.1', 'status': ['stableinterface'], 'supported_by': 'certified'} DOCUMENTATION = r''' --- module: bigip_irule short_description: Manage iRules across different modules on a BIG-IP description: - Manage iRules across different modules on a BIG-IP. version_added: 2.2 options: content: description: - When used instead of 'src', sets the contents of an iRule directly to the specified value. This is for simple values, but can be used with lookup plugins for anything complex or with formatting. Either one of C(src) or C(content) must be provided. type: str module: description: - The BIG-IP module to add the iRule to. type: str required: True choices: - ltm - gtm name: description: - The name of the iRule. type: str required: True src: description: - The iRule file to interpret and upload to the BIG-IP. Either one of C(src) or C(content) must be provided. type: path required: True state: description: - Whether the iRule should exist or not. type: str choices: - present - absent default: present partition: description: - Device partition to manage resources on. type: str default: Common version_added: 2.5 extends_documentation_fragment: f5 author: - Tim Rupp (@caphrim007) - Wojciech Wypior (@wojtek0806) ''' EXAMPLES = r''' - name: Add the iRule contained in template irule.tcl to the LTM module bigip_irule: content: "{{ lookup('template', 'irule.tcl') }}" module: ltm name: MyiRule state: present provider: user: admin password: secret server: lb.mydomain.com delegate_to: localhost - name: Add the iRule contained in static file irule.tcl to the LTM module bigip_irule: module: ltm name: MyiRule src: irule.tcl state: present provider: user: admin password: secret server: lb.mydomain.com delegate_to: localhost ''' RETURN = r''' module: description: The module that the iRule was added to returned: changed and success type: str sample: gtm src: description: The filename that included the iRule source returned: changed and success, when provided type: str sample: /opt/src/irules/example1.tcl content: description: The content of the iRule that was managed returned: changed and success type: str sample: "when LB_FAILED { set wipHost [LB::server addr] }" ''' import os from ansible.module_utils.basic import AnsibleModule from ansible.module_utils.basic import env_fallback try: from library.module_utils.network.f5.bigip import F5RestClient from library.module_utils.network.f5.common import F5ModuleError from library.module_utils.network.f5.common import AnsibleF5Parameters from library.module_utils.network.f5.common import f5_argument_spec from library.module_utils.network.f5.common import transform_name except ImportError: from ansible.module_utils.network.f5.bigip import F5RestClient from ansible.module_utils.network.f5.common import F5ModuleError from ansible.module_utils.network.f5.common import AnsibleF5Parameters from ansible.module_utils.network.f5.common import f5_argument_spec from ansible.module_utils.network.f5.common import transform_name class Parameters(AnsibleF5Parameters): api_map = { 'apiAnonymous': 'content', } updatables = [ 'content', ] api_attributes = [ 'apiAnonymous', ] returnables = [ 'content', 'src', 'module', ] class ApiParameters(Parameters): pass class ModuleParameters(Parameters): @property def content(self): if self._values['content'] is None: result = self.src_content else: result = self._values['content'] return str(result).strip() @property def src(self): if self._values['src'] is None: return None return self._values['src'] @property def src_content(self): if not os.path.exists(self._values['src']): raise F5ModuleError( "The specified 'src' was not found." ) with open(self._values['src']) as f: result = f.read() return result class Changes(Parameters): def to_return(self): result = {} for returnable in self.returnables: result[returnable] = getattr(self, returnable) result = self._filter_params(result) return result class UsableChanges(Changes): pass class ReportableChanges(Changes): pass class Difference(object): def __init__(self, want, have=None): self.want = want self.have = have def compare(self, param): try: result = getattr(self, param) return result except AttributeError: return self.__default(param) def __default(self, param): attr1 = getattr(self.want, param) try: attr2 = getattr(self.have, param) if attr1 != attr2: return attr1 except AttributeError: return attr1 class ModuleManager(object): def __init__(self, *args, **kwargs): self.client = kwargs.get('client', None) self.module = kwargs.get('module', None) self.kwargs = kwargs def exec_module(self): if self.module.params['module'] == 'ltm': manager = self.get_manager('ltm') elif self.module.params['module'] == 'gtm': manager = self.get_manager('gtm') else: raise F5ModuleError( "An unknown iRule module type was specified" ) return manager.exec_module() def get_manager(self, type): if type == 'ltm': return LtmManager(**self.kwargs) elif type == 'gtm': return GtmManager(**self.kwargs) class BaseManager(object): def __init__(self, *args, **kwargs): self.module = kwargs.get('module', None) self.client = F5RestClient(**self.module.params) self.have = None self.want = ModuleParameters(params=self.module.params) self.changes = UsableChanges() def _set_changed_options(self): changed = {} for key in Parameters.returnables: if getattr(self.want, key) is not None: changed[key] = getattr(self.want, key) if changed: self.changes = UsableChanges(params=changed) def _update_changed_options(self): diff = Difference(self.want, self.have) updatables = Parameters.updatables changed = dict() for k in updatables: change = diff.compare(k) if change is None: continue else: if isinstance(change, dict): changed.update(change) else: changed[k] = change if changed: self.changes = UsableChanges(params=changed) return True return False def _announce_deprecations(self, result): warnings = result.pop('__warnings', []) for warning in warnings: self.module.deprecate( msg=warning['msg'], version=warning['version'] ) def exec_module(self): changed = False result = dict() state = self.want.state if state in ["present"]: changed = self.present() elif state == "absent": changed = self.absent() reportable = ReportableChanges(params=self.changes.to_return()) changes = reportable.to_return() result.update(**changes) result.update(dict(changed=changed)) self._announce_deprecations(result) return result def present(self): if not self.want.content and not self.want.src: raise F5ModuleError( "Either 'content' or 'src' must be provided" ) if self.exists(): return self.update() else: return self.create() def create(self): self._set_changed_options() if self.module.check_mode: return True self.create_on_device() if not self.exists(): raise F5ModuleError("Failed to create the iRule") return True def should_update(self): result = self._update_changed_options() if result: return True return False def update(self): self.have = self.read_current_from_device() if not self.should_update(): return False if self.module.check_mode: return True self.update_on_device() return True def absent(self): if self.exists(): return self.remove() return False def remove(self): if self.module.check_mode: return True self.remove_from_device() if self.exists(): raise F5ModuleError("Failed to delete the iRule") return True class LtmManager(BaseManager): def exists(self): uri = "https://{0}:{1}/mgmt/tm/ltm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) resp = self.client.api.get(uri) try: response = resp.json() except ValueError: return False if resp.status == 404 or 'code' in response and response['code'] == 404: return False return True def update_on_device(self): params = self.changes.api_params() uri = "https://{0}:{1}/mgmt/tm/ltm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) resp = self.client.api.patch(uri, json=params) try: response = resp.json() except ValueError as ex: raise F5ModuleError(str(ex)) if 'code' in response and response['code'] == 400: if 'message' in response: raise F5ModuleError(response['message']) else: raise F5ModuleError(resp.content) def create_on_device(self): params = self.changes.api_params() params['name'] = self.want.name params['partition'] = self.want.partition uri = "https://{0}:{1}/mgmt/tm/ltm/rule/".format( self.client.provider['server'], self.client.provider['server_port'], ) resp = self.client.api.post(uri, json=params) try: response = resp.json() except ValueError as ex: raise F5ModuleError(str(ex)) if 'code' in response and response['code'] in [400, 403]: if 'message' in response: raise F5ModuleError(response['message']) else: raise F5ModuleError(resp.content) return response['selfLink'] def read_current_from_device(self): uri = "https://{0}:{1}/mgmt/tm/ltm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) resp = self.client.api.get(uri) try: response = resp.json() except ValueError as ex: raise F5ModuleError(str(ex)) if 'code' in response and response['code'] == 400: if 'message' in response: raise F5ModuleError(response['message']) else: raise F5ModuleError(resp.content) return ApiParameters(params=response) def remove_from_device(self): uri = "https://{0}:{1}/mgmt/tm/ltm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) response = self.client.api.delete(uri) if response.status == 200: return True raise F5ModuleError(response.content) class GtmManager(BaseManager): def exists(self): uri = "https://{0}:{1}/mgmt/tm/gtm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) resp = self.client.api.get(uri) try: response = resp.json() except ValueError: return False if resp.status == 404 or 'code' in response and response['code'] == 404: return False return True def update_on_device(self): params = self.changes.api_params() uri = "https://{0}:{1}/mgmt/tm/gtm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) resp = self.client.api.patch(uri, json=params) try: response = resp.json() except ValueError as ex: raise F5ModuleError(str(ex)) if 'code' in response and response['code'] == 400: if 'message' in response: raise F5ModuleError(response['message']) else: raise F5ModuleError(resp.content) def create_on_device(self): params = self.changes.api_params() params['name'] = self.want.name params['partition'] = self.want.partition uri = "https://{0}:{1}/mgmt/tm/gtm/rule/".format( self.client.provider['server'], self.client.provider['server_port'], ) resp = self.client.api.post(uri, json=params) try: response = resp.json() except ValueError as ex: raise F5ModuleError(str(ex)) if 'code' in response and response['code'] in [400, 403]: if 'message' in response: raise F5ModuleError(response['message']) else: raise F5ModuleError(resp.content) return response['selfLink'] def read_current_from_device(self): uri = "https://{0}:{1}/mgmt/tm/gtm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) resp = self.client.api.get(uri) try: response = resp.json() except ValueError as ex: raise F5ModuleError(str(ex)) if 'code' in response and response['code'] == 400: if 'message' in response: raise F5ModuleError(response['message']) else: raise F5ModuleError(resp.content) return ApiParameters(params=response) def remove_from_device(self): uri = "https://{0}:{1}/mgmt/tm/gtm/rule/{2}".format( self.client.provider['server'], self.client.provider['server_port'], transform_name(self.want.partition, self.want.name) ) response = self.client.api.delete(uri) if response.status == 200: return True raise F5ModuleError(response.content) class ArgumentSpec(object): def __init__(self): self.supports_check_mode = True argument_spec = dict( content=dict(), src=dict( type='path', ), name=dict(required=True), module=dict( required=True, choices=['gtm', 'ltm'] ), state=dict( default='present', choices=['present', 'absent'] ), partition=dict( default='Common', fallback=(env_fallback, ['F5_PARTITION']) ) ) self.argument_spec = {} self.argument_spec.update(f5_argument_spec) self.argument_spec.update(argument_spec) self.mutually_exclusive = [ ['content', 'src'] ] def main(): spec = ArgumentSpec() module = AnsibleModule( argument_spec=spec.argument_spec, supports_check_mode=spec.supports_check_mode, mutually_exclusive=spec.mutually_exclusive ) try: mm = ModuleManager(module=module) results = mm.exec_module() module.exit_json(**results) except F5ModuleError as ex: module.fail_json(msg=str(ex)) if __name__ == '__main__': main()

gpl-3.0

stephane-martin/salt-debian-packaging

salt-2016.3.3/tests/unit/cloud/clouds/dimensiondata_test.py

2

4949

# -*- coding: utf-8 -*- ''' :codeauthor: `Anthony Shaw <anthonyshaw@apache.org>` tests.unit.cloud.clouds.dimensiondata_test ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ''' # Import Python libs from __future__ import absolute_import import libcloud.security import platform import os # Import Salt Libs from salt.cloud.clouds import dimensiondata from salt.exceptions import SaltCloudSystemExit # Import Salt Testing Libs from salttesting import TestCase, skipIf from salttesting.mock import MagicMock, NO_MOCK, NO_MOCK_REASON, patch from salttesting.helpers import ensure_in_syspath ensure_in_syspath('../../../') # Global Variables dimensiondata.__active_provider_name__ = '' dimensiondata.__opts__ = { 'providers': { 'my-dimensiondata-cloud': { 'dimensiondata': { 'driver': 'dimensiondata', 'region': 'dd-au', 'user_id': 'jon_snow', 'key': 'IKnowNothing' } } } } VM_NAME = 'winterfell' HAS_CERTS = True ON_SUSE = True if 'SuSE' in platform.dist() else False ON_MAC = True if 'Darwin' in platform.system() else False if not os.path.exists('/etc/ssl/certs/YaST-CA.pem') and ON_SUSE: if os.path.isfile('/etc/ssl/ca-bundle.pem'): libcloud.security.CA_CERTS_PATH.append('/etc/ssl/ca-bundle.pem') else: HAS_CERTS = False elif ON_MAC: if os.path.isfile('/opt/local/share/curl/curl-ca-bundle.crt'): pass # libcloud will already find this file elif os.path.isfile('/usr/local/etc/openssl/cert.pem'): pass # libcloud will already find this file else: HAS_CERTS = False class ExtendedTestCase(TestCase): ''' Extended TestCase class containing additional helper methods. ''' def assertRaisesWithMessage(self, exc_type, exc_msg, func, *args, **kwargs): try: func(*args, **kwargs) self.assertFail() except Exception as exc: self.assertEqual(type(exc), exc_type) self.assertEqual(exc.message, exc_msg) @skipIf(not HAS_CERTS, 'Cannot find CA cert bundle') @skipIf(NO_MOCK, NO_MOCK_REASON) @patch('salt.cloud.clouds.dimensiondata.__virtual__', MagicMock(return_value='dimensiondata')) class DimensionDataTestCase(ExtendedTestCase): ''' Unit TestCase for salt.cloud.clouds.dimensiondata module. ''' def test_avail_images_call(self): ''' Tests that a SaltCloudSystemExit is raised when trying to call avail_images with --action or -a. ''' self.assertRaises( SaltCloudSystemExit, dimensiondata.avail_images, call='action' ) def test_avail_locations_call(self): ''' Tests that a SaltCloudSystemExit is raised when trying to call avail_locations with --action or -a. ''' self.assertRaises( SaltCloudSystemExit, dimensiondata.avail_locations, call='action' ) def test_avail_sizes_call(self): ''' Tests that a SaltCloudSystemExit is raised when trying to call avail_sizes with --action or -a. ''' self.assertRaises( SaltCloudSystemExit, dimensiondata.avail_sizes, call='action' ) def test_list_nodes_call(self): ''' Tests that a SaltCloudSystemExit is raised when trying to call list_nodes with --action or -a. ''' self.assertRaises( SaltCloudSystemExit, dimensiondata.list_nodes, call='action' ) def test_destroy_call(self): ''' Tests that a SaltCloudSystemExit is raised when trying to call destroy with --function or -f. ''' self.assertRaises( SaltCloudSystemExit, dimensiondata.destroy, name=VM_NAME, call='function' ) def test_avail_sizes(self): ''' Tests that avail_sizes returns an empty dictionary. ''' sizes = dimensiondata.avail_sizes(call='foo') self.assertEqual( len(sizes), 1 ) self.assertEqual( sizes['default']['name'], 'default' ) @patch('libcloud.compute.drivers.dimensiondata.DimensionDataNodeDriver.list_nodes', MagicMock(return_value=[])) def test_list_nodes(self): nodes = dimensiondata.list_nodes() self.assertEqual( nodes, {} ) @patch('libcloud.compute.drivers.dimensiondata.DimensionDataNodeDriver.list_locations', MagicMock(return_value=[])) def test_list_locations(self): locations = dimensiondata.avail_locations() self.assertEqual( locations, {} ) if __name__ == '__main__': from integration import run_tests run_tests(DimensionDataTestCase, needs_daemon=False)

apache-2.0

damian1976/openstack-accounting

util/server.py

1

4730

from .os_data import AccountData import unicodedata import re # 'Server' class # Contains all server accounting data class Server(AccountData): def __init__(self, name): AccountData.__init__(self) m_name = unicodedata.normalize('NFD', re.sub("[\(\[].*?[\)\]]", "", name)).\ encode('ascii', 'ignore') self.__name = m_name.decode('UTF-8') #self.__name = name self.__id = '' self.__state = 'active' self.__projectId = '' self.__projectName = '' def setName(self, name): self.__name = name def getName(self): return self.__name def setId(self, id): self.__id = id def getId(self): return self.__id def setState(self, state): self.__state = state def getState(self): return self.__state def setProjectId(self, id): self.__projectId = id def getProjectId(self): return self.__projectId def setProjectName(self, name): self.__projectName = name def getProjectName(self): return self.__projectName def __repr__(self): return "<Server>" # Returns String representation for a server object def __str__(self): str = "Server name: {0} ({1})\n" \ "\tHours: {2:.2f}\n" \ "\tCPU Hours: {3:.2f}\n" \ "\tCPU Hours cost: {4:.2f}\n" \ "\tRAM GB-Hours: {5:.2f}\n" \ "\tRAM GB-Hours cost: {6:.2f}\n" \ "\tDisk GB-Hours: {7:.2f}\n" \ "\tDisk GB-Hours cost: {8:.2f}\n" \ "\tServer total cost: {9:.2f}\n" return str.format(self.getName(), self.getId(), self.getHrs(), self.getCPU('hours'), self.getCPU('cost'), self.getRAM('hours'), self.getRAM('cost'), self.getDisk('hours'), self.getDisk('cost'), self.getTotalCost()) # Updates server flavors with STOP. SHELVE statuses from config def updateHoursAndVolumes(self, stop_timeframes, shelve_timeframes, delete_timeframes, coeff, ): if delete_timeframes: for hours in delete_timeframes: self.subHrs(hours) self.subDisk(self.getDisk('value')*hours, 'hours') self.subCPU(self.getCPU('value')*hours, 'hours') self.subRAM(self.getRAM('value')*hours, 'hours') if stop_timeframes and coeff: try: for hours in stop_timeframes: self.subHrs(hours*(1.0 - coeff['stop'])) self.subCPU(self.getCPU('value')*hours*(1.0 - coeff['stop_cpu']), 'hours') self.subRAM(self.getRAM('value')*hours*(1.0 - coeff['stop_ram']), 'hours') self.subDisk(self.getDisk('value')*hours*(1.0 - coeff['stop_disk']), 'hours') except KeyError: pass if shelve_timeframes and coeff: try: for hours in shelve_timeframes: self.subHrs(hours*(1.0 - coeff['shelve'])) self.subCPU(self.getCPU('value')*hours*(1.0 - coeff['shelve_cpu']), 'hours') self.subRAM(self.getRAM('value')*hours*(1.0 - coeff['shelve_ram']), 'hours') self.subDisk(self.getDisk('value')*hours*(1.0 - coeff['shelve_disk']), 'hours') except KeyError: pass if (self.getHrs() == 0.0): self.setCPU(0.0, 'hours') self.setRAM(0.0, 'hours') self.setDisk(0.0, 'hours') # Updates server flavors with ACTIVE status coefficients from config def updateMetricHoursWithActiveStatus(self, coeff): if (not coeff): return self.mulHrs(coeff['active']) self.mulDisk(coeff['active_disk'], 'hours') self.mulCPU(coeff['active_cpu'], 'hours') self.mulRAM(coeff['active_ram'], 'hours') # Returns total cost for a server def getTotalCost(self): try: self.__totalCost = (max( self.getCPU('cost'), self.getRAM('cost') ) + self.getDisk('cost')) except Exception as e: print("Error {0}".format(e)) return 0.0 return self.__totalCost

gpl-2.0

ruslanchasep/bartendro

ui/bartendro/view/ws/drink.py

4

5611

# -*- coding: utf-8 -*- import json from time import sleep from operator import itemgetter from bartendro import app, db, mixer from flask import Flask, request from flask.ext.login import login_required, current_user from werkzeug.exceptions import ServiceUnavailable, BadRequest, InternalServerError from bartendro.model.drink import Drink from bartendro.model.drink_name import DrinkName from bartendro.model.booze import Booze from bartendro.model.drink_booze import DrinkBooze from bartendro.model.dispenser import Dispenser from bartendro.error import BartendroBusyError, BartendroBrokenError, BartendroCantPourError, BartendroCurrentSenseError def ws_make_drink(drink_id): recipe = {} for arg in request.args: disp = int(arg[5:]) recipe[disp] = int(request.args.get(arg)) drink = Drink.query.filter_by(id=int(drink_id)).first() try: app.mixer.make_drink(drink, recipe) except mixer.BartendroCantPourError, err: raise BadRequest(err) except mixer.BartendroBrokenError, err: raise InternalServerError(err) except mixer.BartendroBusyError, err: raise ServiceUnavailable(err) return "ok\n" @app.route('/ws/drink/<int:drink>') def ws_drink(drink): drink_mixer = app.mixer if app.options.must_login_to_dispense and not current_user.is_authenticated(): return "login required" return ws_make_drink(drink) @app.route('/ws/drink/custom') def ws_custom_drink(): if app.options.must_login_to_dispense and not current_user.is_authenticated(): return "login required" return ws_make_drink(0) @app.route('/ws/drink/<int:drink>/available/<int:state>') def ws_drink_available(drink, state): if not drink: db.session.query(Drink).update({'available' : state}) else: db.session.query(Drink).filter(Drink.id==drink).update({'available' : state}) db.session.flush() db.session.commit() return "ok\n" @app.route('/ws/shots/<int:booze_id>') def ws_shots(booze_id): if app.options.must_login_to_dispense and not current_user.is_authenticated(): return "login required" dispensers = db.session.query(Dispenser).all() dispenser = None for d in dispensers: if d.booze.id == booze_id: dispenser = d if not dispenser: return "this booze is not available" try: app.mixer.dispense_shot(dispenser, app.options.shot_size) except mixer.BartendroCantPourError, err: raise BadRequest(err) except mixer.BartendroBrokenError, err: raise InternalServerError(err) except mixer.BartendroBusyError, err: raise ServiceUnavailable(err) return "" @app.route('/ws/drink/<int:id>/load') @login_required def ws_drink_load(id): return drink_load(id) def drink_load(id): drink = Drink.query.filter_by(id=int(id)).first() boozes = [] for booze in drink.drink_boozes: boozes.append((booze.booze_id, booze.value)) drink = { 'id' : id, 'name' : drink.name.name, 'desc' : drink.desc, 'popular' : drink.popular, 'available' : drink.available, 'boozes' : boozes, 'num_boozes' : len(boozes) } return json.dumps(drink) @app.route('/ws/drink/<int:drink>/save', methods=["POST"]) def ws_drink_save(drink): data = request.json['drink'] id = int(data["id"] or 0) if id > 0: drink = Drink.query.filter_by(id=int(id)).first() else: id = 0 drink = Drink() db.session.add(drink) try: drink.name.name = data['name'] drink.desc = data['desc'] if data['popular']: drink.popular = True else: drink.popular = False if data['available']: drink.available = True else: drink.available = False except ValueError: raise BadRequest for selected_booze_id, parts, old_booze_id in data['boozes']: try: selected_booze_id = int(selected_booze_id) # this is the id that comes from the most recent selection old_booze_id = int(old_booze_id) # this id is the id that was previously used by this slot. Used for # cleaning up or updateing existing entries parts = int(parts) except ValueError: raise BadRequest # if the parts are set to zero, remove this drink_booze from this drink if parts == 0: if old_booze_id != 0: for i, dbooze in enumerate(drink.drink_boozes): if dbooze.booze_id == old_booze_id: db.session.delete(drink.drink_boozes[i]) break continue # if there is an old_booze_id, then update the existing entry if old_booze_id > 0: for drink_booze in drink.drink_boozes: if old_booze_id == drink_booze.booze_id: drink_booze.value = parts if (selected_booze_id != drink_booze.booze_id): drink_booze.booze = Booze.query.filter_by(id=selected_booze_id).first() break else: # Create a new drink-booze entry booze = Booze.query.filter_by(id=selected_booze_id).first() DrinkBooze(drink, booze, parts, 0) db.session.commit() mc = app.mc mc.delete("top_drinks") mc.delete("other_drinks") mc.delete("available_drink_list") return drink_load(drink.id)

gpl-2.0

yangbh/Hammer

lib/theHarvester/discovery/baidusearch.py

3

1605

import string import httplib, sys import myparser import re import time class search_baidu: def __init__(self,word,limit,start): self.word=word.replace(' ', '%20') self.results="" self.totalresults="" self.server="www.baidu.com" #self.apiserver="api.search.live.net" self.hostname="www.baidu.com" self.userAgent="(Mozilla/5.0 (Windows; U; Windows NT 6.0;zh-cn; rv:1.9.2) Gecko/20100115 Firefox/3.6" self.quantity="50" self.limit=int(limit) self.bingApi="" self.counter=start def do_search(self): h = httplib.HTTP(self.server) h.putrequest('GET', "/s?wd=%40" + self.word + "&rn=100&pn="+ str(self.counter)) h.putheader('Host', self.hostname) h.putheader('Cookie: H_PS_PSSID=4454_1421_4414_4261_4202_4587; BAIDUID=ABE16F3C528AB718BFDBAAAA76626AC3:SL=0:NR=100:FG=1; BDRCVFR[feWj1Vr5u3D]=mk3SLVN4HKm; sug=3; bdime=0; BD_TMP_CK=true') h.putheader('Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3') h.putheader('User-agent', self.userAgent) h.endheaders() returncode, returnmsg, headers = h.getreply() self.results = h.getfile().read() self.totalresults+= self.results def process(self): while self.counter <= self.limit: self.do_search() # print "\tSearching "+ str(self.counter) + " results..." self.counter+=100 def get_emails(self): rawres=myparser.parser(self.totalresults,self.word) return rawres.emails() def get_hostnames(self): rawres=myparser.parser(self.totalresults,self.word) return rawres.hostnames() def get_allhostnames(self): rawres=myparser.parser(self.totalresults,self.word) return rawres.hostnames_all()

gpl-2.0

yezyilomo/dorm

dorm/db.py

1

39874

from flask import Flask from flaskext.mysql import MySQL import random import collections import hashlib import copy ## Database configuration information ################################### app = Flask(__name__) mysql = MySQL() app.config['MYSQL_DATABASE_USER'] = None app.config['MYSQL_DATABASE_PASSWORD'] = None app.config['MYSQL_DATABASE_DB'] = None app.config['MYSQL_DATABASE_HOST'] = None mysql.init_app(app) ######################################################################### db__name__=None db__tables__=[] def _execute(sql_statement): """This is a method for executing sql statements given as string argument This is for internal use only """ connection=mysql.connect() cursor=connection.cursor() cursor.execute(sql_statement) connection.commit() cursor.close() connection.close() if cursor.description is None: return None else: class empty(object): pass columns=tuple( [column[0] for column in cursor.description] ) obj=empty() obj.columns=columns obj.fetch=cursor.fetchall() return obj def execute(sql_statement): ##This method is for further modification, currently it does the same thing as _execute(sql_statement) """This is a method for executing sql statements given as string argument This is meant for external use """ result= _execute(sql_statement) return result def functions_maker(name): """This is a method used to return objects of class table, it allow users to access database tables through their names """ def new_function(): return actual_table(name) return new_function def configure(**data): """This is a method for configuring a database to be used, It generally accept three specified arguments which are db_user, db_password, db_name and db_host, it's called as db.configure( db_user='your_value',db_name='your_value',db_host='your_value',db_password='your_value' ) in 'database/config.py' file """ app.config['MYSQL_DATABASE_USER'] = data['db_user'] app.config['MYSQL_DATABASE_PASSWORD'] = data['db_password'] app.config['MYSQL_DATABASE_DB'] = data['db_name'] app.config['MYSQL_DATABASE_HOST'] = data['db_host'] global db__name__ db__name__ = data['db_name'] all_tables=_execute("show tables").fetch global db__tables__ for table_name in all_tables: globals().update({ table_name[0] : functions_maker(table_name[0]) }) db__tables__.append(table_name[0]) def hash(string): """This is a method which is used to hash information(eg passwords) for security purpose, it uses sha3 algorithm to hash, and it add some characters to hashed string for increasing security """ hashed=hashlib.sha3_512(string.encode()).hexdigest() additional_security="^dorm@ilo@yezy^#$%!flaskapp^" return hashed+additional_security def drop_tb_with_foreign_key_check(table): """This is a method which is used in droping database tables with argument as a table name to be dropped """ sql_statement="drop table "+table _execute(sql_statement) def drop_tb_without_foreign_key_check(table): """This is a method which is used in droping database tables with argument as a table name to be dropped """ sql_statement="SET FOREIGN_KEY_CHECKS = 0; drop table if exists "+ table +" ; SET FOREIGN_KEY_CHECKS = 1;" _execute(sql_statement) def truncate_tb_with_foreign_key_check(table): """This is a method which is used in truncating database tables with argument as a table name to be truncated """ sql_statement="truncate table "+ table _execute(sql_statement) def truncate_tb_without_foreign_key_check(table): """This is a method which is used in truncating database tables with argument as a table name to be truncated """ sql_statement="SET FOREIGN_KEY_CHECKS = 0; truncate table "+ table+ " ; SET FOREIGN_KEY_CHECKS = 1;" _execute(sql_statement) def create_db(db_name): """This is a method which is used to create database with argument as a database name to be created """ sql_statement="create database "+db_name _execute(sql_statement) def drop_db(db_name): """This is a method which is used in droping database with argument as database name to be dropped """ sql_statement="drop database "+db_name _execute(sql_statement) def get_objects(raw_records, columns, table): """This is the actual method which convert records extracted from a database into record objects, it generally create those objects from class record and assign them attributes corresponding to columns and their values as extracted from a database, It returns a normal tuple containing record objects """ columns=list(columns) for column in table.table__columns__: ##check if there are colums with the same name for joined tables splitted_column=column.split('.') if '.' in column and len( splitted_column )>1: columns[ columns.index( splitted_column[1] ) ]=column ##update column with the format 'table.column' to avoid name conflict Record_list=[] for record in raw_records: rec_object=Record(table) for col, value in zip(columns, record): if "." in col: ##if the column is in a form of table.column make it accessible by using the same format( table.column )######## splitted_col=col.split('.') setattr( rec_object, str(splitted_col[0]), type('name', (object, ), {splitted_col[1]: value}) ) ############################# setattr( rec_object, str(col), value ) Record_list.append( rec_object ) return tuple(Record_list) def get_query_condition(data): """This method format a condition to be used in db query during database update and lookup, it generally returns a formated string with a condition to be used after where clause in a db query """ list_of_strings=[] for key in data: if isinstance(data[key],str): list_of_strings.append( key+"='"+str(data[key])+"'" ) else: list_of_strings.append( key+"="+str(data[key]) ) formated_str=", ".join(list_of_strings) return formated_str def random_table(): """This is not necessary, it's just a method which select a table name randomly from a list of tables in a database used and return it as string """ sql_statement="show tables" all_tables=_execute(sql_statement).fetch rd=random.randint(0,len(all_tables)-1) return all_tables[rd][0] def list_tables(): """This is a method which return all tables in a database as list """ sql_statement="show tables" all_tables=_execute(sql_statement).fetch return list(all_tables) class field(object): """This is a class used to define table fields and their constrains """ def __init__(self,**data): self.model="" self.ref_field="" self.field={"key":None,'sql_statement': "field__name "+data['type'] } if len(data)==2 and 'constrain' in data: self.field['sql_statement']+=" "+data['constrain'] elif len(data)==2 and 'key' in data: self.field['key']=data['key'] elif len(data)==3 and 'constrain' in data and 'key' in data: self.field['sql_statement']+=" "+data['constrain'] self.field['key']=data['key'] elif len(data)==3 and 'key' in data and 'ref' in data: self.field['key']=data['key'] reference=data['ref'].split('.') self.model=reference[0] self.ref_field=reference[1] elif len(data)==4 and 'key' in data and 'ref' in data and 'constrain' in data: self.field['sql_statement']+=" "+data['constrain'] self.field['key']=data['key'] reference=data['ref'].split('.') self.model=reference[0] self.ref_field=reference[1] else: pass class arranged_attrs(type): """This is a metaclass intended to arrange model attributes the way they were defined """ def __new__(cls, name, bases, attrs): class_=type.__new__(cls,name, bases,attrs) class_.all__fields__=attrs return class_ @classmethod def __prepare__(mcls, cls, bases): """This is a method which arrange model attributes as they were defined """ return collections.OrderedDict() class model(object, metaclass=arranged_attrs): """This is a class which is used to define raw database(schema), it's inherited by all classes used in creating database tables """ def create(self): """This is a method used to create database table(s) """ create_statement="create table "+str(self.__class__.__name__)+"(" sql_statement="" primary_key="" foreign_key="" for table_field in self.all__fields__: field_value=self.all__fields__[table_field] if isinstance(field_value, field): sql_statement=sql_statement+field_value.field['sql_statement'].replace('field__name',table_field)+" ," if field_value.field['key']=='primary': primary_key+=table_field+" ," if field_value.field['key']=='foreign': foreign_key+=', FOREIGN KEY ('+table_field+') REFERENCES ' +field_value.model+ ' ('+ field_value.ref_field +')' primary_key='PRIMARY KEY('+primary_key[:len(primary_key)-1]+")" create_statement=create_statement+sql_statement+primary_key+foreign_key+")" _execute(create_statement) class partial_table(object): """This is a class for defining partial table as object, it's the result of using select statement, which tends to eliminate some columns and produce a partial table """ def __init__(self,table, *columns, **kwargs): """This is a constructor method which takes table name as argument and create table object from it """ self.table__name__=table.table__name__ self.table__columns__=table.table__columns__ self.selected__columns__=table.selected__columns__ self.primary__keys__=table.primary__keys__ self.table__type__="partial" columns_to_remove=[] columns_arrangement=[] calculated_columns=[] if len(columns)==1 and isinstance( columns[0], (tuple,list) ) : columns=tuple(columns[0]) if 'all_except' in kwargs.keys() and ( isinstance(kwargs['all_except'], tuple) or isinstance( kwargs['all_except'], list) ): columns_to_remove=list(kwargs['all_except']) del kwargs['all_except'] for col in columns_to_remove: self.table__columns__.remove(col) columns_arrangement =self.table__columns__ + list(kwargs.keys()) calculated_columns=self.table__columns__ elif len(columns)==1 and columns[0]=="*": ##leave selected tables as they were in actual table return else: columns_arrangement=list(columns)+list(kwargs.keys()) self.table__columns__=columns_arrangement for column in kwargs: calculated_columns.append( kwargs[column]+" as "+column ) temp_list=[", ".join(columns), ", ".join(calculated_columns)] if temp_list[0]!="" and temp_list[1]!="" : self.selected__columns__=", ".join(temp_list) elif temp_list[0]!="" and temp_list[1]=="" : self.selected__columns__=temp_list[0] elif temp_list[0]=="" and temp_list[1]!="" : self.selected__columns__=temp_list[1] else: raise Exception("Invalid arguments") def get(self, col=None): """This is a method which returns all records from a database as a custom tuple of objects of record when no argument is passed, but it returns a tuple of values of a specified column passed as a string argument(column name) """ raw_records=_execute("select " +self.selected__columns__+ " from "+str(self.table__name__)) if col is not None: return read_only_records(get_objects(raw_records.fetch, raw_records.columns ,self)).get(col) return read_write_records(get_objects(raw_records.fetch, raw_records.columns,self)) def getd(self,col_name): """This is a method for extracting distinct values in a specified column, it takes string argument as column name from which values are suppossed to be extracted """ return tuple(set(self.get(col_name))) def find(self,**pri_key_with_val): """This is a method for finding a single specific record by using it's primary key(s), here the argument to this method is the dict which contains primary key(s) and it's/their corresponding value(s), the format of argument is { primary_key1: value1, primary_key2: value2, ...} """ primary_keys=pri_key_with_val.keys() if set(pri_key_with_val) != set(self.primary__keys__): #if user provide a non-primary key argument raise Exception("You hava passed non-primary key argument(s)") list_of_strings=[] for key in pri_key_with_val: if isinstance(pri_key_with_val[key],str): list_of_strings.append( key+"='"+str(pri_key_with_val[key])+"'" ) else: list_of_strings.append( key+"="+str(pri_key_with_val[key]) ) condition=" and ".join(list_of_strings) record=self.where(condition) if len(record)==0: return None else: return record[0] def where(self,*data): """This is a method which is used to query and return records from a database as a custom tuple of objects of record, the criteria used to query records is specified as argument(s), This method accept two forms of arguments, the first form is three specified arguments which form a query condition eg where("age", ">", 20), and the second form is a single argument which specify a query condition eg in the first example we could obtain the same result by using where("age > 20") """ sql_statement="" if len(data)==3: col,expr,val=data[0],data[1],data[2] if isinstance(val, list): val=tuple(val) if isinstance(val,str): sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",str(col)," ",str(expr)," ","'",val,"'"]) else: sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",str(col)," ",str(expr)," ",str(val)]) elif len(data)==1 : cond=data[0] sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",cond]) else: raise Exception("Invalid agruments") raw_records=_execute(sql_statement) return read_write_records( get_objects(raw_records.fetch, raw_records.columns, self) ) class computational_table(object): ##this is a class for computations, it's meant to separate computations from normal queries """This is a class for defining a computation database table as object, this table is only meant for computations, it's meant to separate computations from normal queries """ def __init__(self,table, operation,column): """This is a constructor method which takes table name as argument and create table object from it """ self.table__name__=table.table__name__ self.table__type__="computation" self.selected__columns__=selected__columns__=operation+"("+column+")" def get(self): ## get for computations """This is a method which returns all records from a database as a custom tuple of objects of record """ raw_records=_execute("select " +self.selected__columns__+ " from "+str(self.table__name__)) return raw_records.fetch[0][0] def where(self,*data): ## where for computations """This is a method which is used to query and return records from a database as a custom tuple of objects of record, the criteria used to query records is specified as argument(s), This method accept two forms of arguments, the first form is three specified arguments which form a query condition eg where("age", ">", 20), and the second form is a single argument which specify a query condition eg in the first example we could obtain the same result by using where("age > 20") """ sql_statement="" if len(data)==3: col,expr,val=data[0],data[1],data[2] if isinstance(val, list): val=tuple(val) if isinstance(val,str): sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",str(col)," ",str(expr)," ","'",val,"'"]) else: sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",str(col)," ",str(expr)," ",str(val)]) elif len(data)==1 : cond=data[0] sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",cond]) else: raise Exception("Invalid agruments") raw_records=_execute(sql_statement) return raw_records.fetch[0][0] class actual_table(object): """This is a class for defining actual database table as object """ def __init__(self,table_name): """This is a constructor method which takes table name as argument and create table object from it """ self.table__name__=table_name self.selected__columns__="*" self.table__type__="actual" all_cols=_execute("show columns from "+str(self.table__name__)) self.table__columns__=[] for col_name in all_cols.fetch: self.table__columns__.append( str(col_name[0]) ) keys=_execute("show index from "+str(self.table__name__)+" where Key_name='PRIMARY'").fetch self.primary__keys__=[] for key in keys: self.primary__keys__.append( str(key[4]) ) def select(self, *columns, **kwargs ): """This is a method which is used to select several columns to be included in SQL query, it accept a number of arguments which are column names passed as strings, if you want to select all columns except few columns you can pass all_except=['column1', 'column2', ...] as kwarg """ partial_tb=partial_table(self, *columns, **kwargs) ##Here we use partial_table because not all columns are going to be included in select statement return partial_tb def selectd(self, *columns, **kwargs): """This is a method which is used to select several distinct columns to be included in SQL query, it accept a number of arguments which are column names passed as strings, if you want to select all columns except few columns you can pass all_except=['column1', 'column2', ...] as kwarg """ partial_tb=partial_table(self, *columns, **kwargs) ##Here we use partial_table because not all columns are going to be included in select statement partial_tb.selected__columns__="distinct "+partial_tb.selected__columns__ return partial_tb def max(self,column): calc_table=computational_table(self,'max',column) return calc_table def min(self,column): calc_table=computational_table(self,'min',column) return calc_table def sum(self,column): calc_table=computational_table(self,'sum',column) return calc_table def avg(self,column): calc_table=computational_table(self,'avg',column) return calc_table def count(self,column="*"): calc_table=computational_table(self,'count',column) return calc_table def get(self, col='no_column'): """This is a method which returns all records from a database as a custom tuple of objects of record when no argument is passed, but it returns a tuple of values of a specified column passed as a string argument(column name) """ raw_records=_execute("select " +self.selected__columns__+ " from "+str(self.table__name__)) if self.table__type__=="computation": return raw_records.fetch[0][0] if col != 'no_column': return read_only_records(get_objects(raw_records.fetch, raw_records.columns ,self)).get(col) return read_write_records(get_objects(raw_records.fetch, raw_records.columns,self)) def getd(self,col_name): """This is a method for extracting distinct values in a specified column, it takes string argument as column name from which values are suppossed to be extracted """ return tuple(set(self.get(col_name))) def find(self,**pri_key_with_val): """This is a method for finding a single specific record by using it's primary key(s), here the argument to this method is the dict which contains primary key(s) and it's/their corresponding value(s), the format of argument is { primary_key1: value1, primary_key2: value2, ...} """ primary_keys=pri_key_with_val.keys() if set(pri_key_with_val) != set(self.primary__keys__) : #if user provide a non-primary key argument raise Exception("You hava passed non-primary key argument(s)") list_of_strings=[] for key in pri_key_with_val: if isinstance(pri_key_with_val[key],str): list_of_strings.append( key+"='"+str(pri_key_with_val[key])+"'" ) else: list_of_strings.append( key+"="+str(pri_key_with_val[key]) ) condition=" and ".join(list_of_strings) record=self.where(condition) if len(record)==0: return None else: return record[0] def where(self,*data): """This is a method which is used to query and return records from a database as a custom tuple of objects of record, the criteria used to query records is specified as argument(s), This method accept two forms of arguments, the first form is three specified arguments which form a query condition eg where("age", ">", 20), and the second form is a single argument which specify a query condition eg in the first example we could obtain the same result by using where("age > 20") """ sql_statement="" if len(data)==3: col,expr,val=data[0],data[1],data[2] if isinstance(val, list): val=tuple(val) if isinstance(val,str): sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",str(col)," ",str(expr)," ","'",val,"'"]) else: sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",str(col)," ",str(expr)," ",str(val)]) elif len(data)==1 : cond=data[0] sql_statement=''.join(["select " +self.selected__columns__+ " from ",str(self.table__name__)," where ",cond]) else: raise Exception("Invalid agruments") raw_records=_execute(sql_statement) if self.table__type__=="computation": return raw_records.fetch[0][0] return read_write_records( get_objects(raw_records.fetch, raw_records.columns, self) ) def values_to_insert(self,data): """This is a method which format values as string to be used in insertion query """ values="(" if isinstance(data, dict): for key, value in data.items(): if isinstance(value,str): values=values+"'"+value+"'," else : values=values+str(value)+"," elif isinstance(data, tuple): for value in data: if isinstance(value,str): values=values+"'"+value+"'," else : values=values+str(value)+"," values=values[:len(values)-1]+")" return values def insert(self,*values,**data): """This is a method which is used to insert records into a database table, with specified arguments as columns and their corresponding values to insert into a database, It generally returns a record which has been inserted into your database """ if len(values)==0 and len(data) > 0: sql_statement="insert into "+ str(self.table__name__) +" (" +", ".join(list(data.keys()))+ ") values "+self.values_to_insert(data) elif len(data)==0 and len(values) == len(self.table__columns__): sql_statement="insert into "+ str(self.table__name__) + " values "+self.values_to_insert(values) elif len(data)==0 and len(values) == 1 and isinstance(values[0], dict): sql_statement="insert into "+ str(self.table__name__) +" (" +", ".join(list(values[0].keys()))+ ") values "+self.values_to_insert(values[0]) else: raise Exception("Invalid arguments to 'insert' function") _execute(sql_statement) def join(self,table2,join_type='inner'): """This is a method which is used in joining database tables with first arguments as table name to join to, and second argument as join type which is inner by default, it returns an instance of FlatTable, where different operations can be done """ table1=self table2=actual_table(table2) whole_table=FlatTable(join_type,table1,table2) return whole_table class FlatTable(object): """This is a class which defines a table formed as a result of joining two tables """ def __init__(self,join_type, table1, table2): """This is a constructor which initializes a table with important parameters """ self.table__name__=table1.table__name__+"_and_"+table2.table__name__ self.tables__=[table1.table__name__, table2.table__name__] self.table__type__='partial' self.join__type__=join_type self.on__condition__="" self.selected__columns__="*" flat_table_columns=table1.table__columns__ + table2.table__columns__ flat_table_primary_keys=table1.primary__keys__ + table2.primary__keys__ duplicate_colums=[key for key in set(flat_table_columns) if flat_table_columns.count(key)>1] ##Identify columns with name collision and assign them full name ie table_name.column_name for col in duplicate_colums: if col in flat_table_primary_keys and flat_table_primary_keys.count(col)>1: flat_table_primary_keys[flat_table_primary_keys.index(col)]=table1.table__name__+'.'+col flat_table_primary_keys[flat_table_primary_keys.index(col)]=table1.table__name__+'.'+col flat_table_columns[flat_table_columns.index(col)]=table1.table__name__+'.'+col flat_table_columns[flat_table_columns.index(col)]=table2.table__name__+'.'+col self.table__columns__=flat_table_columns self.primary__keys__=flat_table_primary_keys def on(self,*data): """This is a method which specify on condition to be used in joining tables """ if len(data)==3: col1, op, col2=data[0], data[0], data[0] self.on__condition__=col1+ op + col2 elif len(data)==1: self.on__condition__=data[0] else: raise Exception("Invalid arguments") return self def get(self, column=None): """This is a method which returns all records from a database as a custom tuple of objects of record when no argument is passed, but it returns a tuple of values of a specified column passed as a string argument(column name) """ sql_statement="SELECT " +self.selected__columns__+ " FROM " +self.tables__[0]+ " " +self.join__type__+ " JOIN " +self.tables__[1]+" on "+self.on__condition__ raw_records=_execute(sql_statement) if self.table__type__=="computation": return raw_records.fetch[0][0] elif column is not None: rec_objects=get_objects(raw_records.fetch, raw_records.columns, self) return tuple( [ getattr(record, column) for record in rec_objects ] ) return read_only_records(get_objects(raw_records.fetch, raw_records.columns, self)) def getd(self,col_name): """This is a method for extracting distinct values in a specified column, it takes string argument as column name from which values are suppossed to be extracted """ return tuple(set(self.get(col_name))) def where(self, *data): """This is a method which is used to query and return records from a database as a custom tuple of objects of record, the criteria used to query records is specified as argument(s), This method accept two forms of arguments, the first form is three specified arguments which form a query condition eg where("age", ">", 20), and the second form is a single argument which specify a query condition eg in the first example we could obtain the same result by using where("age > 20") """ sql_statement="" if len(data)==3: col,expr,val=data[0],data[1],data[2] sql_statement="SELECT " +self.selected__columns__+ " FROM " +self.tables__[0]+ " " +self.join__type__+ " JOIN " +self.tables__[1]+" on "+self.on__condition__+ " where "+str(col)+" "+str(expr)+" "+str(val) elif len(data)==1: cond=data[0] sql_statement="SELECT " +self.selected__columns__+ " FROM " +self.tables__[0]+ " " +self.join__type__+ " JOIN " +self.tables__[1]+" on "+self.on__condition__+" where "+cond else: raise Exception("Invalid agruments") raw_records=_execute(sql_statement) if self.table__type__=="computation": return raw_records.fetch[0][0] return read_only_records(get_objects(raw_records.fetch, raw_records.columns, self)) def select(self, *columns, **kwargs): """This is a method which is used to select several columns to be included in SQL query, it accept a number of arguments which are column names passed as strings, if you want to select all columns except few columns you can pass all_except=['column1', 'column2', ...] as kwarg """ tb_copy=copy.deepcopy(self) tb_copy.table__type__="partial" columns_to_remove=[] columns_arrangement=[] calculated_columns=[] if len(columns)==1 and isinstance( columns[0], (tuple,list) ) : columns=tuple(columns[0]) if 'all_except' in kwargs.keys() and ( isinstance(kwargs['all_except'], tuple) or isinstance(kwargs['all_except'], list) ): columns_to_remove=list(kwargs['all_except']) del kwargs['all_except'] for col in columns_to_remove: tb_copy.table__columns__.remove(col) columns_arrangement=tb_copy.table__columns__+list(kwargs.keys()) calculated_columns=tb_copy.table__columns__ else: columns_arrangement=list(columns)+list(kwargs.keys()) tb_copy.table__columns__=columns_arrangement for column in kwargs: calculated_columns.append( kwargs[column]+" as "+column ) temp_list=[", ".join(columns), ", ".join(calculated_columns)] if temp_list[0]!="" and temp_list[1]!="" : tb_copy.selected__columns__=", ".join(temp_list) elif temp_list[0]!="" and temp_list[1]=="" : tb_copy.selected__columns__=temp_list[0] elif temp_list[0]=="" and temp_list[1]!="" : tb_copy.selected__columns__=temp_list[1] else: raise Exception("Invalid arguments") return tb_copy def selectd(self, *colums, **kwargs): """This is a method which is used to select several distinct columns to be included in SQL query, it accept a number of arguments which are column names passed as strings, if you want to select all columns except few columns you can pass all_except=['column1', 'column2', ...] as kwarg """ partial_tb=select(*colums,**kwargs) ##Here we use partial_table because not all columns are going to be included in select statement partial_tb.selected__columns__="distinct "+partial_tb.selected__columns__ return partial_tb def max(self,column): tb_copy=copy.deepcopy(self) tb_copy.selected__columns__='max('+column+')' tb_copy.table__type__="computation" return tb_copy def min(self,column): tb_copy=copy.deepcopy(self) tb_copy.selected__columns__='min('+column+')' tb_copy.table__type__="computation" return tb_copy def sum(self,column): tb_copy=copy.deepcopy(self) tb_copy.selected__columns__='sum('+column+')' tb_copy.table__type__="computation" return tb_copy def avg(self,column): tb_copy=copy.deepcopy(self) tb_copy.selected__columns__='avg('+column+')' tb_copy.table__type__="computation" return tb_copy def count(self,column="*"): tb_copy=copy.deepcopy(self) tb_copy.selected__columns__='count('+column+')' tb_copy.table__type__="computation" return tb_copy def find(self, **pri_key_with_val): """This is a method for finding a single specific record by using it's primary key(s), here the argument to this method is the dict which contains primary key(s) and it's/their corresponding value(s), the format of argument is { primary_key1: value1, primary_key2: value2, ...} """ if len(pri_key_with_val)==0: raise Exception("Invalid arguments, Please pass primary key(s) for finding your record") primary_keys=pri_key_with_val.keys() if set(pri_key_with_val) != set(self.primary__keys__) : #if user provide a non-primary key argument raise Exception("You hava passed non-primary key argument(s)") list_of_strings=[] for key in pri_key_with_val: if isinstance(pri_key_with_val[key],str): list_of_strings.append( key+"='"+str(pri_key_with_val[key])+"'" ) else: list_of_strings.append( key+"="+str(pri_key_with_val[key]) ) condition=" and ".join(list_of_strings) record=self.where(condition) if len(record)==0: return None else: return record[0] class Record(object): """This is a class for defining records as objects, It generally produce objects which corresponds to records extracted from a certain database table """ def __init__(self, table): """This is a constructor which initializes record object with import parameters from table object which is passed as the argument to it """ self.table__name__=table.table__name__ self.table__columns__=table.table__columns__ self.primary__keys__=table.primary__keys__ def get_query_values(self, data): """This method format string to be used as condition in finding a record during record deletion and update, it generally return a formated string with values to be inserted in a db table """ list_of_strings=[] for column in data: val=getattr( self, str(column) ) if isinstance(val,str): list_of_strings.append( column+"='"+str(val)+"'" ) else: list_of_strings.append( column+"="+str(val) ) formated_str=" and ".join( list_of_strings ) return formated_str def update(self, *update_values, **data): """This is the actual method for updating a specific record in a database with arguments as column names and their corresponding values for the record """ if len(update_values)==0 and len(data)>0: values=get_query_condition(data) condition=self.get_query_values(self.primary__keys__) sql_statement="update "+ str(self.table__name__)+" set "+values+" where "+ condition elif len(update_values)==1 and isinstance(update_values[0], dict) and len(data)==0: values=get_query_condition(update_values[0]) condition=self.get_query_values(self.primary__keys__) sql_statement="update "+ str(self.table__name__)+" set "+values+" where "+ condition _execute(sql_statement) def delete(self): """This is the actual method for deleting a specific record in a database """ condition=self.get_query_values(self.primary__keys__) sql_statement="delete from "+ str(self.table__name__)+" where "+ condition _execute(sql_statement) class read_only_records(tuple): """This is a class for converting a normal tuple into a custom tuple which has some import methods like count, get etc, for record manipulations """ def count(self): """This is a method for counting records """ return len(self) def get_column_values(self,col_name): """This returns all values in a given column """ for record in self: yield getattr(record, col_name) def get(self,col_name): """This is a method for extracting values in a specified column, it takes string argument as column name from which values are suppossed to be extracted """ col_vals=tuple(self.get_column_values(col_name)) return col_vals def getd(self,col_name): """This is a method for extracting distinct values in a specified column, it takes string argument as column name from which values are suppossed to be extracted """ return tuple(set(self.get(col_name))) def ensure_one(self): """This is a method for ensuring that only one record is returned and not a tuple or custom_tuple of records """ if len(self)==1: return self[0] else: raise Exception("There is more than one records") class read_write_records(read_only_records): """This is a class for converting a normal tuple into a custom tuple which has some import methods like update, delete etc, for record manipulations """ def update(self, *update_values, **data): """This is a method helper for updating a group of specific records in a database with arguments as column names and their corresponding values for the record """ for record in self: record.update(*update_values, **data) def delete(self): """This is a method helper for deleting a group of specific records in a database """ for record in self: record.delete()

gpl-3.0

lancezlin/ml_template_py

lib/python2.7/site-packages/nbconvert/preprocessors/highlightmagics.py

9

3251

"""This preprocessor detect cells using a different language through magic extensions such as `%%R` or `%%octave`. Cell's metadata is marked so that the appropriate highlighter can be used in the `highlight` filter. """ # Copyright (c) Jupyter Development Team. # Distributed under the terms of the Modified BSD License. from __future__ import print_function, absolute_import import re from .base import Preprocessor from traitlets import Dict class HighlightMagicsPreprocessor(Preprocessor): """ Detects and tags code cells that use a different languages than Python. """ # list of magic language extensions and their associated pygment lexers default_languages = Dict({ '%%R': 'r', '%%bash': 'bash', '%%cython': 'cython', '%%javascript': 'javascript', '%%julia': 'julia', '%%latex': 'latex', '%%octave': 'octave', '%%perl': 'perl', '%%ruby': 'ruby', '%%sh': 'sh', }) # user defined language extensions languages = Dict( help=("Syntax highlighting for magic's extension languages. " "Each item associates a language magic extension such as %%R, " "with a pygments lexer such as r.") ).tag(config=True) def __init__(self, config=None, **kw): """Public constructor""" super(HighlightMagicsPreprocessor, self).__init__(config=config, **kw) # Update the default languages dict with the user configured ones self.default_languages.update(self.languages) # build a regular expression to catch language extensions and choose # an adequate pygments lexer any_language = "|".join(self.default_languages.keys()) self.re_magic_language = re.compile( r'^\s*({0})\s+'.format(any_language)) def which_magic_language(self, source): """ When a cell uses another language through a magic extension, the other language is returned. If no language magic is detected, this function returns None. Parameters ---------- source: str Source code of the cell to highlight """ m = self.re_magic_language.match(source) if m: # By construction of the re, the matched language must be in the # languages dictionary return self.default_languages[m.group(1)] else: return None def preprocess_cell(self, cell, resources, cell_index): """ Tags cells using a magic extension language Parameters ---------- cell : NotebookNode cell Notebook cell being processed resources : dictionary Additional resources used in the conversion process. Allows preprocessors to pass variables into the Jinja engine. cell_index : int Index of the cell being processed (see base.py) """ # Only tag code cells if cell.cell_type == "code": magic_language = self.which_magic_language(cell.source) if magic_language: cell['metadata']['magics_language'] = magic_language return cell, resources

mit

piffey/ansible

lib/ansible/modules/network/cloudengine/ce_netstream_aging.py

43

18023

#!/usr/bin/python # # This file is part of Ansible # # Ansible is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # Ansible 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Ansible. If not, see <http://www.gnu.org/licenses/>. # ANSIBLE_METADATA = {'metadata_version': '1.1', 'status': ['preview'], 'supported_by': 'community'} DOCUMENTATION = """ --- module: ce_netstream_aging version_added: "2.4" short_description: Manages timeout mode of NetStream on HUAWEI CloudEngine switches. description: - Manages timeout mode of NetStream on HUAWEI CloudEngine switches. author: YangYang (@CloudEngine-Ansible) options: timeout_interval: description: - Netstream timeout interval. If is active type the interval is 1-60. If is inactive ,the interval is 5-600. default: 30 type: description: - Specifies the packet type of netstream timeout active interval. choices: ['ip', 'vxlan'] state: description: - Specify desired state of the resource. choices: ['present', 'absent'] default: present timeout_type: description: - Netstream timeout type. choices: ['active', 'inactive', 'tcp-session', 'manual'] manual_slot: description: - Specifies the slot number of netstream manual timeout. """ EXAMPLES = ''' - name: netstream aging module test hosts: cloudengine connection: local gather_facts: no vars: cli: host: "{{ inventory_hostname }}" port: "{{ ansible_ssh_port }}" username: "{{ username }}" password: "{{ password }}" transport: cli tasks: - name: Configure netstream ip timeout active interval , the interval is 40 minutes. ce_netstream_aging: timeout_interval: 40 type: ip timeout_type: active state: present provider: "{{ cli }}" - name: Configure netstream vxlan timeout active interval , the interval is 40 minutes. ce_netstream_aging: timeout_interval: 40 type: vxlan timeout_type: active active_state: present provider: "{{ cli }}" - name: Delete netstream ip timeout active interval , set the ip timeout interval to 30 minutes. ce_netstream_aging: type: ip timeout_type: active state: absent provider: "{{ cli }}" - name: Delete netstream vxlan timeout active interval , set the vxlan timeout interval to 30 minutes. ce_netstream_aging: type: vxlan timeout_type: active state: absent provider: "{{ cli }}" - name: Enable netstream ip tcp session timeout. ce_netstream_aging: type: ip timeout_type: tcp-session state: present provider: "{{ cli }}" - name: Enable netstream vxlan tcp session timeout. ce_netstream_aging: type: vxlan timeout_type: tcp-session state: present provider: "{{ cli }}" - name: Disable netstream ip tcp session timeout. ce_netstream_aging: type: ip timeout_type: tcp-session state: absent provider: "{{ cli }}" - name: Disable netstream vxlan tcp session timeout. ce_netstream_aging: type: vxlan timeout_type: tcp-session state: absent provider: "{{ cli }}" ''' RETURN = ''' proposed: description: k/v pairs of parameters passed into module returned: verbose mode type: dict sample: {"timeout_interval": "40", "type": "ip", "state": "absent", "timeout_type": active} existing: description: k/v pairs of existing configuration returned: verbose mode type: dict sample: {"active_timeout": [ { "ip": "40", "vxlan": 30 } ], "inactive_timeout": [ { "ip": 30, "vxlan": 30 } ], "tcp_timeout": [ { "ip": "disable", "vxlan": "disable" } ]} end_state: description: k/v pairs of configuration after module execution returned: verbose mode type: dict sample: {"active_timeout": [ { "ip": 30, "vxlan": 30 } ], "inactive_timeout": [ { "ip": 30, "vxlan": 30 } ], "tcp_timeout": [ { "ip": "disable", "vxlan": "disable" } ]} updates: description: commands sent to the device returned: always type: list sample: ["undo netstream timeout ip active 40"] changed: description: check to see if a change was made on the device returned: always type: boolean sample: true ''' from ansible.module_utils.basic import AnsibleModule from ansible.module_utils.network.cloudengine.ce import get_config, load_config from ansible.module_utils.network.cloudengine.ce import ce_argument_spec class NetStreamAging(object): """ Manages netstream aging. """ def __init__(self, argument_spec): self.spec = argument_spec self.module = None self.init_module() # module input info self.timeout_interval = self.module.params['timeout_interval'] self.type = self.module.params['type'] self.state = self.module.params['state'] self.timeout_type = self.module.params['timeout_type'] self.manual_slot = self.module.params['manual_slot'] # host info self.host = self.module.params['host'] self.username = self.module.params['username'] self.port = self.module.params['port'] # state self.changed = False self.updates_cmd = list() self.commands = list() self.results = dict() self.proposed = dict() self.existing = dict() self.end_state = dict() # local parameters self.existing["active_timeout"] = list() self.existing["inactive_timeout"] = list() self.existing["tcp_timeout"] = list() self.end_state["active_timeout"] = list() self.end_state["inactive_timeout"] = list() self.end_state["tcp_timeout"] = list() self.active_changed = False self.inactive_changed = False self.tcp_changed = False def init_module(self): """init module""" self.module = AnsibleModule(argument_spec=self.spec, supports_check_mode=True) def cli_load_config(self, commands): """load config by cli""" if not self.module.check_mode: load_config(self.module, commands) def cli_add_command(self, command, undo=False): """add command to self.update_cmd and self.commands""" if undo and command.lower() not in ["quit", "return"]: cmd = "undo " + command else: cmd = command self.commands.append(cmd) if command.lower() not in ["quit", "return"]: self.updates_cmd.append(cmd) def get_exist_timer_out_para(self): """Get exist netstream timeout parameters""" active_tmp = dict() inactive_tmp = dict() tcp_tmp = dict() active_tmp["ip"] = "30" active_tmp["vxlan"] = "30" inactive_tmp["ip"] = "30" inactive_tmp["vxlan"] = "30" tcp_tmp["ip"] = "absent" tcp_tmp["vxlan"] = "absent" flags = list() exp = " | ignore-case include netstream timeout" flags.append(exp) config = get_config(self.module, flags) if config: config = config.lstrip() config_list = config.split('\n') for config_mem in config_list: config_mem = config_mem.lstrip() config_mem_list = config_mem.split(' ') if config_mem_list[2] == "ip": if config_mem_list[3] == "active": active_tmp["ip"] = config_mem_list[4] if config_mem_list[3] == "inactive": inactive_tmp["ip"] = config_mem_list[4] if config_mem_list[3] == "tcp-session": tcp_tmp["ip"] = "present" if config_mem_list[2] == "vxlan": if config_mem_list[4] == "active": active_tmp["vxlan"] = config_mem_list[5] if config_mem_list[4] == "inactive": inactive_tmp["vxlan"] = config_mem_list[5] if config_mem_list[4] == "tcp-session": tcp_tmp["vxlan"] = "present" self.existing["active_timeout"].append(active_tmp) self.existing["inactive_timeout"].append(inactive_tmp) self.existing["tcp_timeout"].append(tcp_tmp) def get_end_timer_out_para(self): """Get end netstream timeout parameters""" active_tmp = dict() inactive_tmp = dict() tcp_tmp = dict() active_tmp["ip"] = "30" active_tmp["vxlan"] = "30" inactive_tmp["ip"] = "30" inactive_tmp["vxlan"] = "30" tcp_tmp["ip"] = "absent" tcp_tmp["vxlan"] = "absent" flags = list() exp = " | ignore-case include netstream timeout" exp = "| ignore-case include evpn-overlay enable" flags.append(exp) config = get_config(self.module, flags) if config: config = config.lstrip() config_list = config.split('\n') for config_mem in config_list: config_mem = config_mem.lstrip() config_mem_list = config_mem.split(' ') if config_mem_list[2] == "ip": if config_mem_list[3] == "active": active_tmp["ip"] = config_mem_list[4] if config_mem_list[3] == "inactive": inactive_tmp["ip"] = config_mem_list[4] if config_mem_list[3] == "tcp-session": tcp_tmp["ip"] = "present" if config_mem_list[2] == "vxlan": if config_mem_list[4] == "active": active_tmp["vxlan"] = config_mem_list[5] if config_mem_list[4] == "inactive": inactive_tmp["vxlan"] = config_mem_list[5] if config_mem_list[4] == "tcp-session": tcp_tmp["vxlan"] = "present" self.end_state["active_timeout"].append(active_tmp) self.end_state["inactive_timeout"].append(inactive_tmp) self.end_state["tcp_timeout"].append(tcp_tmp) def check_params(self): """Check all input params""" # interval check if not str(self.timeout_interval).isdigit(): self.module.fail_json( msg='Error: Timeout interval should be numerical.') if self.timeout_type == "active": if int(self.timeout_interval) < 1 or int(self.timeout_interval) > 60: self.module.fail_json( msg="Error: Active interval should between 1 - 60 minutes.") if self.timeout_type == "inactive": if int(self.timeout_interval) < 5 or int(self.timeout_interval) > 600: self.module.fail_json( msg="Error: Inactive interval should between 5 - 600 seconds.") if self.timeout_type == "manual": if not self.manual_slot: self.module.fail_json( msg="Error: If use manual timeout mode,slot number is needed.") if not str(self.manual_slot).isdigit(): self.module.fail_json( msg='Error: Slot number should be numerical.') def get_proposed(self): """get proposed info""" if self.timeout_interval: self.proposed["timeout_interval"] = self.timeout_interval if self.timeout_type: self.proposed["timeout_type"] = self.timeout_type if self.type: self.proposed["type"] = self.type if self.state: self.proposed["state"] = self.state if self.manual_slot: self.proposed["manual_slot"] = self.manual_slot def get_existing(self): """get existing info""" active_tmp = dict() inactive_tmp = dict() tcp_tmp = dict() self.get_exist_timer_out_para() if self.timeout_type == "active": for active_tmp in self.existing["active_timeout"]: if self.state == "present": if str(active_tmp[self.type]) != self.timeout_interval: self.active_changed = True else: if self.timeout_interval != "30": if str(active_tmp[self.type]) != "30": if str(active_tmp[self.type]) != self.timeout_interval: self.module.fail_json( msg='Error: The specified active interval do not exist.') if str(active_tmp[self.type]) != "30": self.timeout_interval = active_tmp[self.type] self.active_changed = True if self.timeout_type == "inactive": for inactive_tmp in self.existing["inactive_timeout"]: if self.state == "present": if str(inactive_tmp[self.type]) != self.timeout_interval: self.inactive_changed = True else: if self.timeout_interval != "30": if str(inactive_tmp[self.type]) != "30": if str(inactive_tmp[self.type]) != self.timeout_interval: self.module.fail_json( msg='Error: The specified inactive interval do not exist.') if str(inactive_tmp[self.type]) != "30": self.timeout_interval = inactive_tmp[self.type] self.inactive_changed = True if self.timeout_type == "tcp-session": for tcp_tmp in self.existing["tcp_timeout"]: if str(tcp_tmp[self.type]) != self.state: self.tcp_changed = True def operate_time_out(self): """configure timeout parameters""" cmd = "" if self.timeout_type == "manual": if self.type == "ip": self.cli_add_command("quit") cmd = "reset netstream cache ip slot %s" % self.manual_slot self.cli_add_command(cmd) elif self.type == "vxlan": self.cli_add_command("quit") cmd = "reset netstream cache vxlan inner-ip slot %s" % self.manual_slot self.cli_add_command(cmd) if not self.active_changed and not self.inactive_changed and not self.tcp_changed: if self.commands: self.cli_load_config(self.commands) self.changed = True return if self.active_changed or self.inactive_changed: if self.type == "ip": cmd = "netstream timeout ip %s %s" % (self.timeout_type, self.timeout_interval) elif self.type == "vxlan": cmd = "netstream timeout vxlan inner-ip %s %s" % (self.timeout_type, self.timeout_interval) if self.state == "absent": self.cli_add_command(cmd, undo=True) else: self.cli_add_command(cmd) if self.timeout_type == "tcp-session" and self.tcp_changed: if self.type == "ip": if self.state == "present": cmd = "netstream timeout ip tcp-session" else: cmd = "undo netstream timeout ip tcp-session" elif self.type == "vxlan": if self.state == "present": cmd = "netstream timeout vxlan inner-ip tcp-session" else: cmd = "undo netstream timeout vxlan inner-ip tcp-session" self.cli_add_command(cmd) if self.commands: self.cli_load_config(self.commands) self.changed = True def get_end_state(self): """get end state info""" self.get_end_timer_out_para() def work(self): """worker""" self.check_params() self.get_existing() self.get_proposed() self.operate_time_out() self.get_end_state() self.results['changed'] = self.changed self.results['proposed'] = self.proposed self.results['existing'] = self.existing self.results['end_state'] = self.end_state if self.changed: self.results['updates'] = self.updates_cmd else: self.results['updates'] = list() self.module.exit_json(**self.results) def main(): """Module main""" argument_spec = dict( timeout_interval=dict(required=False, type='str', default='30'), type=dict(required=False, choices=['ip', 'vxlan']), state=dict(required=False, choices=['present', 'absent'], default='present'), timeout_type=dict(required=False, choices=['active', 'inactive', 'tcp-session', 'manual']), manual_slot=dict(required=False, type='str'), ) argument_spec.update(ce_argument_spec) module = NetStreamAging(argument_spec) module.work() if __name__ == '__main__': main()

gpl-3.0

ccastell/Transfer-System

Website/env/lib/python3.5/site-packages/django/apps/registry.py

51

17239

import sys import threading import warnings from collections import Counter, OrderedDict, defaultdict from functools import partial from django.core.exceptions import AppRegistryNotReady, ImproperlyConfigured from django.utils import lru_cache from .config import AppConfig class Apps(object): """ A registry that stores the configuration of installed applications. It also keeps track of models eg. to provide reverse-relations. """ def __init__(self, installed_apps=()): # installed_apps is set to None when creating the master registry # because it cannot be populated at that point. Other registries must # provide a list of installed apps and are populated immediately. if installed_apps is None and hasattr(sys.modules[__name__], 'apps'): raise RuntimeError("You must supply an installed_apps argument.") # Mapping of app labels => model names => model classes. Every time a # model is imported, ModelBase.__new__ calls apps.register_model which # creates an entry in all_models. All imported models are registered, # regardless of whether they're defined in an installed application # and whether the registry has been populated. Since it isn't possible # to reimport a module safely (it could reexecute initialization code) # all_models is never overridden or reset. self.all_models = defaultdict(OrderedDict) # Mapping of labels to AppConfig instances for installed apps. self.app_configs = OrderedDict() # Stack of app_configs. Used to store the current state in # set_available_apps and set_installed_apps. self.stored_app_configs = [] # Whether the registry is populated. self.apps_ready = self.models_ready = self.ready = False # Lock for thread-safe population. self._lock = threading.Lock() # Maps ("app_label", "modelname") tuples to lists of functions to be # called when the corresponding model is ready. Used by this class's # `lazy_model_operation()` and `do_pending_operations()` methods. self._pending_operations = defaultdict(list) # Populate apps and models, unless it's the master registry. if installed_apps is not None: self.populate(installed_apps) def populate(self, installed_apps=None): """ Loads application configurations and models. This method imports each application module and then each model module. It is thread safe and idempotent, but not reentrant. """ if self.ready: return # populate() might be called by two threads in parallel on servers # that create threads before initializing the WSGI callable. with self._lock: if self.ready: return # app_config should be pristine, otherwise the code below won't # guarantee that the order matches the order in INSTALLED_APPS. if self.app_configs: raise RuntimeError("populate() isn't reentrant") # Phase 1: initialize app configs and import app modules. for entry in installed_apps: if isinstance(entry, AppConfig): app_config = entry else: app_config = AppConfig.create(entry) if app_config.label in self.app_configs: raise ImproperlyConfigured( "Application labels aren't unique, " "duplicates: %s" % app_config.label) self.app_configs[app_config.label] = app_config app_config.apps = self # Check for duplicate app names. counts = Counter( app_config.name for app_config in self.app_configs.values()) duplicates = [ name for name, count in counts.most_common() if count > 1] if duplicates: raise ImproperlyConfigured( "Application names aren't unique, " "duplicates: %s" % ", ".join(duplicates)) self.apps_ready = True # Phase 2: import models modules. for app_config in self.app_configs.values(): app_config.import_models() self.clear_cache() self.models_ready = True # Phase 3: run ready() methods of app configs. for app_config in self.get_app_configs(): app_config.ready() self.ready = True def check_apps_ready(self): """ Raises an exception if all apps haven't been imported yet. """ if not self.apps_ready: raise AppRegistryNotReady("Apps aren't loaded yet.") def check_models_ready(self): """ Raises an exception if all models haven't been imported yet. """ if not self.models_ready: raise AppRegistryNotReady("Models aren't loaded yet.") def get_app_configs(self): """ Imports applications and returns an iterable of app configs. """ self.check_apps_ready() return self.app_configs.values() def get_app_config(self, app_label): """ Imports applications and returns an app config for the given label. Raises LookupError if no application exists with this label. """ self.check_apps_ready() try: return self.app_configs[app_label] except KeyError: message = "No installed app with label '%s'." % app_label for app_config in self.get_app_configs(): if app_config.name == app_label: message += " Did you mean '%s'?" % app_config.label break raise LookupError(message) # This method is performance-critical at least for Django's test suite. @lru_cache.lru_cache(maxsize=None) def get_models(self, include_auto_created=False, include_swapped=False): """ Returns a list of all installed models. By default, the following models aren't included: - auto-created models for many-to-many relations without an explicit intermediate table, - models that have been swapped out. Set the corresponding keyword argument to True to include such models. """ self.check_models_ready() result = [] for app_config in self.app_configs.values(): result.extend(list(app_config.get_models(include_auto_created, include_swapped))) return result def get_model(self, app_label, model_name=None, require_ready=True): """ Returns the model matching the given app_label and model_name. As a shortcut, this function also accepts a single argument in the form <app_label>.<model_name>. model_name is case-insensitive. Raises LookupError if no application exists with this label, or no model exists with this name in the application. Raises ValueError if called with a single argument that doesn't contain exactly one dot. """ if require_ready: self.check_models_ready() else: self.check_apps_ready() if model_name is None: app_label, model_name = app_label.split('.') app_config = self.get_app_config(app_label) if not require_ready and app_config.models is None: app_config.import_models() return app_config.get_model(model_name, require_ready=require_ready) def register_model(self, app_label, model): # Since this method is called when models are imported, it cannot # perform imports because of the risk of import loops. It mustn't # call get_app_config(). model_name = model._meta.model_name app_models = self.all_models[app_label] if model_name in app_models: if (model.__name__ == app_models[model_name].__name__ and model.__module__ == app_models[model_name].__module__): warnings.warn( "Model '%s.%s' was already registered. " "Reloading models is not advised as it can lead to inconsistencies, " "most notably with related models." % (app_label, model_name), RuntimeWarning, stacklevel=2) else: raise RuntimeError( "Conflicting '%s' models in application '%s': %s and %s." % (model_name, app_label, app_models[model_name], model)) app_models[model_name] = model self.do_pending_operations(model) self.clear_cache() def is_installed(self, app_name): """ Checks whether an application with this name exists in the registry. app_name is the full name of the app eg. 'django.contrib.admin'. """ self.check_apps_ready() return any(ac.name == app_name for ac in self.app_configs.values()) def get_containing_app_config(self, object_name): """ Look for an app config containing a given object. object_name is the dotted Python path to the object. Returns the app config for the inner application in case of nesting. Returns None if the object isn't in any registered app config. """ self.check_apps_ready() candidates = [] for app_config in self.app_configs.values(): if object_name.startswith(app_config.name): subpath = object_name[len(app_config.name):] if subpath == '' or subpath[0] == '.': candidates.append(app_config) if candidates: return sorted(candidates, key=lambda ac: -len(ac.name))[0] def get_registered_model(self, app_label, model_name): """ Similar to get_model(), but doesn't require that an app exists with the given app_label. It's safe to call this method at import time, even while the registry is being populated. """ model = self.all_models[app_label].get(model_name.lower()) if model is None: raise LookupError( "Model '%s.%s' not registered." % (app_label, model_name)) return model @lru_cache.lru_cache(maxsize=None) def get_swappable_settings_name(self, to_string): """ For a given model string (e.g. "auth.User"), return the name of the corresponding settings name if it refers to a swappable model. If the referred model is not swappable, return None. This method is decorated with lru_cache because it's performance critical when it comes to migrations. Since the swappable settings don't change after Django has loaded the settings, there is no reason to get the respective settings attribute over and over again. """ for model in self.get_models(include_swapped=True): swapped = model._meta.swapped # Is this model swapped out for the model given by to_string? if swapped and swapped == to_string: return model._meta.swappable # Is this model swappable and the one given by to_string? if model._meta.swappable and model._meta.label == to_string: return model._meta.swappable return None def set_available_apps(self, available): """ Restricts the set of installed apps used by get_app_config[s]. available must be an iterable of application names. set_available_apps() must be balanced with unset_available_apps(). Primarily used for performance optimization in TransactionTestCase. This method is safe is the sense that it doesn't trigger any imports. """ available = set(available) installed = set(app_config.name for app_config in self.get_app_configs()) if not available.issubset(installed): raise ValueError( "Available apps isn't a subset of installed apps, extra apps: %s" % ", ".join(available - installed) ) self.stored_app_configs.append(self.app_configs) self.app_configs = OrderedDict( (label, app_config) for label, app_config in self.app_configs.items() if app_config.name in available) self.clear_cache() def unset_available_apps(self): """ Cancels a previous call to set_available_apps(). """ self.app_configs = self.stored_app_configs.pop() self.clear_cache() def set_installed_apps(self, installed): """ Enables a different set of installed apps for get_app_config[s]. installed must be an iterable in the same format as INSTALLED_APPS. set_installed_apps() must be balanced with unset_installed_apps(), even if it exits with an exception. Primarily used as a receiver of the setting_changed signal in tests. This method may trigger new imports, which may add new models to the registry of all imported models. They will stay in the registry even after unset_installed_apps(). Since it isn't possible to replay imports safely (eg. that could lead to registering listeners twice), models are registered when they're imported and never removed. """ if not self.ready: raise AppRegistryNotReady("App registry isn't ready yet.") self.stored_app_configs.append(self.app_configs) self.app_configs = OrderedDict() self.apps_ready = self.models_ready = self.ready = False self.clear_cache() self.populate(installed) def unset_installed_apps(self): """ Cancels a previous call to set_installed_apps(). """ self.app_configs = self.stored_app_configs.pop() self.apps_ready = self.models_ready = self.ready = True self.clear_cache() def clear_cache(self): """ Clears all internal caches, for methods that alter the app registry. This is mostly used in tests. """ # Call expire cache on each model. This will purge # the relation tree and the fields cache. self.get_models.cache_clear() if self.ready: # Circumvent self.get_models() to prevent that the cache is refilled. # This particularly prevents that an empty value is cached while cloning. for app_config in self.app_configs.values(): for model in app_config.get_models(include_auto_created=True): model._meta._expire_cache() def lazy_model_operation(self, function, *model_keys): """ Take a function and a number of ("app_label", "modelname") tuples, and when all the corresponding models have been imported and registered, call the function with the model classes as its arguments. The function passed to this method must accept exactly n models as arguments, where n=len(model_keys). """ # Base case: no arguments, just execute the function. if not model_keys: function() # Recursive case: take the head of model_keys, wait for the # corresponding model class to be imported and registered, then apply # that argument to the supplied function. Pass the resulting partial # to lazy_model_operation() along with the remaining model args and # repeat until all models are loaded and all arguments are applied. else: next_model, more_models = model_keys[0], model_keys[1:] # This will be executed after the class corresponding to next_model # has been imported and registered. The `func` attribute provides # duck-type compatibility with partials. def apply_next_model(model): next_function = partial(apply_next_model.func, model) self.lazy_model_operation(next_function, *more_models) apply_next_model.func = function # If the model has already been imported and registered, partially # apply it to the function now. If not, add it to the list of # pending operations for the model, where it will be executed with # the model class as its sole argument once the model is ready. try: model_class = self.get_registered_model(*next_model) except LookupError: self._pending_operations[next_model].append(apply_next_model) else: apply_next_model(model_class) def do_pending_operations(self, model): """ Take a newly-prepared model and pass it to each function waiting for it. This is called at the very end of `Apps.register_model()`. """ key = model._meta.app_label, model._meta.model_name for function in self._pending_operations.pop(key, []): function(model) apps = Apps(installed_apps=None)

apache-2.0

BurtBiel/azure-cli

src/command_modules/azure-cli-keyvault/azure/cli/command_modules/keyvault/custom.py

1

9777

#--------------------------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. #--------------------------------------------------------------------------------------------- from msrestazure.azure_exceptions import CloudError from azure.mgmt.keyvault.models import (VaultCreateOrUpdateParameters, VaultProperties, AccessPolicyEntry, Permissions, Sku, SkuName) from azure.graphrbac import GraphRbacManagementClient from azure.cli.core._util import CLIError import azure.cli.core._logging as _logging logger = _logging.get_az_logger(__name__) def list_keyvault(client, resource_group_name=None): ''' List Vaults. ''' vault_list = client.list_by_resource_group(resource_group_name=resource_group_name) \ if resource_group_name else client.list() return list(vault_list) def _get_current_user_object_id(graph_client): try: current_user = graph_client.objects.get_current_user() if current_user and current_user.object_id: #pylint:disable=no-member return current_user.object_id #pylint:disable=no-member except CloudError: pass def _get_object_id_by_spn(graph_client, spn): accounts = list(graph_client.service_principals.list( filter="servicePrincipalNames/any(c:c eq '{}')".format(spn))) if not accounts: logger.warning("Unable to find user with spn '%s'", spn) return if len(accounts) > 1: logger.warning("Multiple service principals found with spn '%s'. "\ "You can avoid this by specifying object id.", spn) return return accounts[0].object_id def _get_object_id_by_upn(graph_client, upn): accounts = list(graph_client.users.list(filter="userPrincipalName eq '{}'".format(upn))) if not accounts: logger.warning("Unable to find user with upn '%s'", upn) return if len(accounts) > 1: logger.warning("Multiple users principals found with upn '%s'. "\ "You can avoid this by specifying object id.", upn) return return accounts[0].object_id def _get_object_id_from_subscription(graph_client, subscription): if subscription['user']: if subscription['user']['type'] == 'user': return _get_object_id_by_upn(graph_client, subscription['user']['name']) elif subscription['user']['type'] == 'servicePrincipal': return _get_object_id_by_spn(graph_client, subscription['user']['name']) else: logger.warning("Unknown user type '%s'", subscription['user']['type']) else: logger.warning('Current credentials are not from a user or service principal. '\ 'Azure Key Vault does not work with certificate credentials.') def _get_object_id(graph_client, subscription=None, spn=None, upn=None): if spn: return _get_object_id_by_spn(graph_client, spn) if upn: return _get_object_id_by_upn(graph_client, upn) return _get_object_id_from_subscription(graph_client, subscription) def create_keyvault(client, resource_group_name, vault_name, location, #pylint:disable=too-many-arguments sku=SkuName.standard.value, enabled_for_deployment=None, enabled_for_disk_encryption=None, enabled_for_template_deployment=None, no_self_perms=False, tags=None): from azure.cli.core._profile import Profile profile = Profile() cred, _, tenant_id = profile.get_login_credentials(for_graph_client=True) graph_client = GraphRbacManagementClient(cred, tenant_id) subscription = profile.get_subscription() if no_self_perms: access_policies = [] else: # TODO Use the enums instead of strings when new keyvault SDK is released # https://github.com/Azure/azure-sdk-for-python/blob/dev/azure-mgmt-keyvault/ # azure/mgmt/keyvault/models/key_vault_management_client_enums.py permissions = Permissions(keys=['get', 'create', 'delete', 'list', 'update', 'import', 'backup', 'restore'], secrets=['all']) object_id = _get_current_user_object_id(graph_client) if not object_id: object_id = _get_object_id(graph_client, subscription=subscription) if not object_id: raise CLIError('Cannot create vault.\n' 'Unable to query active directory for information '\ 'about the current user.\n' 'You may try the --no-self-perms flag to create a vault'\ ' without permissions.') access_policies = [AccessPolicyEntry(tenant_id=tenant_id, object_id=object_id, permissions=permissions)] properties = VaultProperties(tenant_id=tenant_id, sku=Sku(name=sku), access_policies=access_policies, vault_uri=None, enabled_for_deployment=enabled_for_deployment, enabled_for_disk_encryption=enabled_for_disk_encryption, enabled_for_template_deployment=enabled_for_template_deployment) parameters = VaultCreateOrUpdateParameters(location=location, tags=tags, properties=properties) return client.create_or_update(resource_group_name=resource_group_name, vault_name=vault_name, parameters=parameters) create_keyvault.__doc__ = VaultProperties.__doc__ def _object_id_args_helper(object_id, spn, upn): if not object_id: from azure.cli.core._profile import Profile profile = Profile() cred, _, tenant_id = profile.get_login_credentials(for_graph_client=True) graph_client = GraphRbacManagementClient(cred, tenant_id) object_id = _get_object_id(graph_client, spn=spn, upn=upn) if not object_id: raise CLIError('Unable to get object id from principal name.') return object_id def set_policy(client, resource_group_name, vault_name, #pylint:disable=too-many-arguments object_id=None, spn=None, upn=None, perms_to_keys=None, perms_to_secrets=None): object_id = _object_id_args_helper(object_id, spn, upn) vault = client.get(resource_group_name=resource_group_name, vault_name=vault_name) # Find the existing policy to set policy = next((p for p in vault.properties.access_policies \ if object_id.lower() == p.object_id.lower() and \ vault.properties.tenant_id.lower() == p.tenant_id.lower()), None) if not policy: # Add new policy as none found vault.properties.access_policies.append(AccessPolicyEntry( tenant_id=vault.properties.tenant_id, object_id=object_id, permissions=Permissions(keys=perms_to_keys, secrets=perms_to_secrets))) else: # Modify existing policy. # If perms_to_keys is not set, use prev. value (similarly with perms_to_secrets). keys = policy.permissions.keys if perms_to_keys is None else perms_to_keys secrets = policy.permissions.secrets if perms_to_secrets is None else perms_to_secrets policy.permissions = Permissions(keys=keys, secrets=secrets) return client.create_or_update(resource_group_name=resource_group_name, vault_name=vault_name, parameters=VaultCreateOrUpdateParameters( location=vault.location, tags=vault.tags, properties=vault.properties)) def delete_policy(client, resource_group_name, vault_name, object_id=None, spn=None, upn=None): #pylint:disable=too-many-arguments object_id = _object_id_args_helper(object_id, spn, upn) vault = client.get(resource_group_name=resource_group_name, vault_name=vault_name) prev_policies_len = len(vault.properties.access_policies) vault.properties.access_policies = [p for p in vault.properties.access_policies if \ vault.properties.tenant_id.lower() != p.tenant_id.lower() \ or object_id.lower() != p.object_id.lower()] if len(vault.properties.access_policies) == prev_policies_len: raise CLIError('No matching policies found') return client.create_or_update(resource_group_name=resource_group_name, vault_name=vault_name, parameters=VaultCreateOrUpdateParameters( location=vault.location, tags=vault.tags, properties=vault.properties))

mit

gaolichuang/py-essential

tests/test_imageutils.py

2

7736

# Copyright (C) 2012 Yahoo! Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import testscenarios from essential import imageutils from essential import test load_tests = testscenarios.load_tests_apply_scenarios class ImageUtilsRawTestCase(test.BaseTestCase): _image_name = [ ('disk_config', dict(image_name='disk.config')), ] _file_format = [ ('raw', dict(file_format='raw')), ] _virtual_size = [ ('64M', dict(virtual_size='64M', exp_virtual_size=67108864)), ('64M_with_byte_hint', dict(virtual_size='64M (67108844 bytes)', exp_virtual_size=67108844)), ('64M_byte', dict(virtual_size='67108844', exp_virtual_size=67108844)), ('4.4M', dict(virtual_size='4.4M', exp_virtual_size=4613735)), ('4.4M_with_byte_hint', dict(virtual_size='4.4M (4592640 bytes)', exp_virtual_size=4592640)), ('2K', dict(virtual_size='2K', exp_virtual_size=2048)), ('2K_with_byte_hint', dict(virtual_size='2K (2048 bytes)', exp_virtual_size=2048)), ] _disk_size = [ ('96K', dict(disk_size='96K', exp_disk_size=98304)), ('96K_byte', dict(disk_size='963434', exp_disk_size=963434)), ('3.1M', dict(disk_size='3.1G', exp_disk_size=3328599655)), ] _garbage_before_snapshot = [ ('no_garbage', dict(garbage_before_snapshot=None)), ('garbage_before_snapshot_list', dict(garbage_before_snapshot=False)), ('garbage_after_snapshot_list', dict(garbage_before_snapshot=True)), ] _snapshot_count = [ ('no_snapshots', dict(snapshot_count=None)), ('one_snapshots', dict(snapshot_count=1)), ('three_snapshots', dict(snapshot_count=3)), ] @classmethod def generate_scenarios(cls): cls.scenarios = testscenarios.multiply_scenarios( cls._image_name, cls._file_format, cls._virtual_size, cls._disk_size, cls._garbage_before_snapshot, cls._snapshot_count) def _initialize_img_info(self): return ('image: %s' % self.image_name, 'file_format: %s' % self.file_format, 'virtual_size: %s' % self.virtual_size, 'disk_size: %s' % self.disk_size) def _insert_snapshots(self, img_info): img_info = img_info + ('Snapshot list:',) img_info = img_info + ('ID ' 'TAG ' 'VM SIZE ' 'DATE ' 'VM CLOCK',) for i in range(self.snapshot_count): img_info = img_info + ('%d ' 'd9a9784a500742a7bb95627bb3aace38 ' '0 2012-08-20 10:52:46 ' '00:00:00.000' % (i + 1),) return img_info def _base_validation(self, image_info): self.assertEqual(image_info.image, self.image_name) self.assertEqual(image_info.file_format, self.file_format) self.assertEqual(image_info.virtual_size, self.exp_virtual_size) self.assertEqual(image_info.disk_size, self.exp_disk_size) if self.snapshot_count is not None: self.assertEqual(len(image_info.snapshots), self.snapshot_count) def test_qemu_img_info(self): img_info = self._initialize_img_info() if self.garbage_before_snapshot is True: img_info = img_info + ('blah BLAH: bb',) if self.snapshot_count is not None: img_info = self._insert_snapshots(img_info) if self.garbage_before_snapshot is False: img_info = img_info + ('junk stuff: bbb',) example_output = '\n'.join(img_info) image_info = imageutils.QemuImgInfo(example_output) self._base_validation(image_info) ImageUtilsRawTestCase.generate_scenarios() class ImageUtilsQemuTestCase(ImageUtilsRawTestCase): _file_format = [ ('qcow2', dict(file_format='qcow2')), ] _qcow2_cluster_size = [ ('65536', dict(cluster_size='65536', exp_cluster_size=65536)), ] _qcow2_encrypted = [ ('no_encryption', dict(encrypted=None)), ('encrypted', dict(encrypted='yes')), ] _qcow2_backing_file = [ ('no_backing_file', dict(backing_file=None)), ('backing_file_path', dict(backing_file='/var/lib/nova/a328c7998805951a_2', exp_backing_file='/var/lib/nova/a328c7998805951a_2')), ('backing_file_path_with_actual_path', dict(backing_file='/var/lib/nova/a328c7998805951a_2 ' '(actual path: /b/3a988059e51a_2)', exp_backing_file='/b/3a988059e51a_2')), ] @classmethod def generate_scenarios(cls): cls.scenarios = testscenarios.multiply_scenarios( cls._image_name, cls._file_format, cls._virtual_size, cls._disk_size, cls._garbage_before_snapshot, cls._snapshot_count, cls._qcow2_cluster_size, cls._qcow2_encrypted, cls._qcow2_backing_file) def test_qemu_img_info(self): img_info = self._initialize_img_info() img_info = img_info + ('cluster_size: %s' % self.cluster_size,) if self.backing_file is not None: img_info = img_info + ('backing file: %s' % self.backing_file,) if self.encrypted is not None: img_info = img_info + ('encrypted: %s' % self.encrypted,) if self.garbage_before_snapshot is True: img_info = img_info + ('blah BLAH: bb',) if self.snapshot_count is not None: img_info = self._insert_snapshots(img_info) if self.garbage_before_snapshot is False: img_info = img_info + ('junk stuff: bbb',) example_output = '\n'.join(img_info) image_info = imageutils.QemuImgInfo(example_output) self._base_validation(image_info) self.assertEqual(image_info.cluster_size, self.exp_cluster_size) if self.backing_file is not None: self.assertEqual(image_info.backing_file, self.exp_backing_file) if self.encrypted is not None: self.assertEqual(image_info.encrypted, self.encrypted) ImageUtilsQemuTestCase.generate_scenarios() class ImageUtilsBlankTestCase(test.BaseTestCase): def test_qemu_img_info_blank(self): example_output = '\n'.join(['image: None', 'file_format: None', 'virtual_size: None', 'disk_size: None', 'cluster_size: None', 'backing_file: None']) image_info = imageutils.QemuImgInfo() self.assertEqual(str(image_info), example_output) self.assertEqual(len(image_info.snapshots), 0)

apache-2.0

hyiltiz/labyrinth

labyrinth_lib/Browser.py

2

13346

# Browser.py # This file is part of Labyrinth # # Copyright (C) 2006 - Don Scorgie <Don@Scorgie.org> # - Andreas Sliwka <andreas.sliwka@gmail.com> # # Labyrinth is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # Labyrinth 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Labyrinth; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, # Boston, MA 02110-1301 USA # # Standard library import tarfile import os import gettext _ = gettext.gettext # Gtk stuff import gtk if os.name != 'nt': import gconf import gtk.glade import pango import gobject # Local imports import utils import MainWindow from MapList import MapList import TrayIcon from . import __version__ AUTHORS = ['Don Scorgie <Don@Scorgie.org>', 'Martin Schaaf <mascha@ma-scha.de>', 'Matthias Vogelgesang <matthias.vogelgesang@gmail.com>', 'Andreas Sliwka <andreas.sliwka@gmail.com>'] class Browser (gtk.Window): COL_ID = 0 COL_TITLE = 1 COL_MODTIME = 2 def __init__(self, start_hidden, tray_icon): super(Browser, self).__init__() self.glade=gtk.glade.XML(utils.get_data_file_name('labyrinth.glade')) self.view = self.glade.get_widget ('MainView') self.populate_view () self.view.connect ('row-activated', self.open_row_cb) self.view.connect ('cursor-changed', self.cursor_change_cb) self.view_dependants = [] self.open_button = self.glade.get_widget('OpenButton') self.delete_button = self.glade.get_widget('DeleteButton') self.open_menu = self.glade.get_widget('open1') self.delete_menu = self.glade.get_widget('delete1') self.view_dependants.append (self.open_button) self.view_dependants.append (self.delete_button) self.view_dependants.append (self.open_menu) self.view_dependants.append (self.delete_menu) self.open_button.connect ('clicked', self.open_clicked) self.glade.get_widget('NewButton').connect ('clicked', self.new_clicked) self.delete_button.connect ('clicked', self.delete_clicked) self.open_menu.connect ('activate', self.open_clicked) self.glade.get_widget('new1').connect ('activate', self.new_clicked) self.delete_menu.connect ('activate', self.delete_clicked) self.glade.get_widget('import1').connect ('activate', self.import_clicked) self.glade.get_widget('quit1').connect ('activate', self.quit_clicked) self.glade.get_widget('about1').connect ('activate', self.about_clicked) self.glade.get_widget('showhelp').connect ('activate', self.show_help_clicked) for x in self.view_dependants: x.set_sensitive(False) self.main_window = self.glade.get_widget ('MapBrowser') # set remembered size if os.name != 'nt': self.config_client = gconf.client_get_default() self.config_client.add_dir ("/apps/labyrinth", gconf.CLIENT_PRELOAD_NONE) width = self.config_client.get_int ('/apps/labyrinth/width') height = self.config_client.get_int ('/apps/labyrinth/height') utils.use_bezier_curves = self.config_client.get_bool ('/apps/labyrinth/curves') if width == 0 or height == 0: width = 400 height = 300 else: width = 400 height = 300 view_sortable = self.view.get_model () view_sortable.connect ('sort-column-changed', self.sort_column_changed_cb) if os.name != 'nt': sort_order = self.config_client.get_int('/apps/labyrinth/map_sort_order') column_id = self.config_client.get_int('/apps/labyrinth/map_sort_order_column') view_sortable.set_sort_column_id (column_id, sort_order) self.main_window.resize (width, height) if os.name != 'nt': try: self.main_window.set_icon_name ('labyrinth') except: self.main_window.set_icon_from_file(utils.get_data_file_name('labyrinth.svg')) else: self.main_window.set_icon_from_file(utils.get_data_file_name('labyrinth-32.png')) if tray_icon: self.main_window.connect ('delete_event', self.toggle_main_window, None) traymenu = gtk.Menu() quit_item = gtk.MenuItem("Quit") quit_item.connect("activate",self.quit_clicked) traymenu.add(quit_item) traymenu.show_all() self.traymenu = traymenu self.trayicon = TrayIcon.TrayIcon( icon_name="labyrinth", menu=traymenu, activate=self.toggle_main_window) else: self.main_window.connect('delete_event', self.quit_clicked, None) if start_hidden: self.main_window.hide () else: self.main_window.show_all () def toggle_main_window(self,*args): if self.main_window.get_property("visible"): self.main_window.hide() else: self.main_window.show() return True def map_title_cb (self, mobj, new_title, mobj1): map = MapList.get_by_window(mobj) if not map: raise AttributeError ("What a mess, can't find the map") map.title = new_title def get_selected_map(self): sel = self.view.get_selection () (model, it) = sel.get_selected () if it: (num,) = MapList.tree_view_model.get (it, self.COL_ID) return MapList.get_by_index(num) return None def cursor_change_cb (self, treeview): sensitive = bool(self.get_selected_map()) for x in self.view_dependants: x.set_sensitive(sensitive) def open_map_filename (self, fname): win = MainWindow.LabyrinthWindow (fname) win.show () def open_map (self, map, imported=False): win = MainWindow.LabyrinthWindow (map.filename, imported) win.connect ("title-changed", self.map_title_cb) win.connect ("window_closed", self.remove_map_cb) win.connect ("file_saved", self.file_save_cb) win.show () map.window = win return (MapList.index(map), win) def open_selected_map(self): map = self.get_selected_map() if map is None: raise ValueError("you clicked the 'open' button but had no map selected") if map.window: print "Window for map '%s' is already open" % map.title # may be the window should be raised? else: self.open_map (map) def show_help_clicked(self, arg): try: gtk.show_uri(None, 'help:labyrinth', 0) except gobject.GError, e: print _('Unable to display help: %s') % str(e) def about_clicked (self, arg): about_dialog = gtk.AboutDialog () about_dialog.set_name ("Labyrinth") about_dialog.set_version (__version__) if os.name != 'nt': try: about_dialog.set_logo_icon_name("labyrinth") except: pass else: about_dialog.set_logo (gtk.gdk.pixbuf_new_from_file( utils.get_data_file_name("labyrinth-32.png"))) about_dialog.set_license ( "Labyrinth is free software; you can redistribute it and/or modify " "it under the terms of the GNU General Public Licence as published by " "the Free Software Foundation; either version 2 of the Licence, or " "(at your option) any later version." "\n\n" "Labyrinth 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 General Public Licence for more details." "\n\n" "You should have received a copy of the GNU General Public Licence " "along with Labyrinth; if not, write to the Free Software Foundation, Inc., " "59 Temple Place, Suite 330, Boston, MA 02111-1307 USA") about_dialog.set_wrap_license (True) about_dialog.set_copyright ("2006-2008 Don Scorgie et. al") about_dialog.set_authors (AUTHORS) about_dialog.set_website ("http://code.google.com/p/labyrinth") about_dialog.set_translator_credits (_("Translation by Don Scorgie")) about_dialog.run () about_dialog.hide () del (about_dialog) return def open_clicked (self, button): self.open_selected_map() def open_row_cb (self, view, path, col): self.open_selected_map () def new_clicked (self, button): map = MapList.create_empty_map() self.open_map(map) def delete_clicked (self, button): map = self.get_selected_map () if not map: raise ValueError("You clicked on delete but had no map selected") error_message = "" if map.window: error_message = _("The map cannot be deleted right now. Is it open?") elif not map.filename: error_message = _("The map has no associated filename.") if error_message: dialog = gtk.MessageDialog (self, gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_OK, _("Cannot delete this map")) dialog.format_secondary_text (error_message) dialog.run () dialog.hide () del (dialog) return dialog = gtk.MessageDialog (self, gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_YES_NO, _("Do you really want to delete this Map?")) resp = dialog.run () dialog.hide () del (dialog) if resp != gtk.RESPONSE_YES: return MapList.delete (map) self.view.emit ('cursor-changed') def remove_map_cb (self, mobj, a): map = MapList.get_by_window(mobj) if map: MapList.delete(map) self.view.emit ('cursor-changed') return raise ValueError("Cant remove map of window %s" % mobj) def file_save_cb (self, mobj, new_fname, mobj1): map = MapList.get_by_window(mobj) if map: map.window = None map.filename = new_fname return def import_clicked(self, button, other=None, *data): chooser = gtk.FileChooserDialog(title=_("Open File"), action=gtk.FILE_CHOOSER_ACTION_OPEN, \ buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) filtr = gtk.FileFilter () filtr.set_name(_('MAPZ Compressed Map (*.mapz)')) filtr.add_pattern('*.mapz') chooser.add_filter(filtr) response = chooser.run() if response == gtk.RESPONSE_OK: filename = chooser.get_filename() tf = tarfile.open(filename) mapname = os.path.join (utils.get_save_dir (), tf.getnames()[0]) tf.extractall(utils.get_save_dir()) tf.close() map = MapList.new_from_file(mapname) map.filename = mapname chooser.destroy() def quit_clicked (self, button, other=None, *data): for map in MapList.get_open_windows(): map.window.close_window_cb (None) width, height = self.main_window.get_size() if os.name != 'nt': self.config_client.set_int('/apps/labyrinth/width', width) self.config_client.set_int('/apps/labyrinth/height', height) gtk.main_quit () def populate_view (self): cellrenderer = gtk.CellRendererText() cellrenderer.set_property("ellipsize", pango.ELLIPSIZE_END) column = gtk.TreeViewColumn(_("Map Name"), cellrenderer, text=self.COL_TITLE) column.set_resizable(True) column.set_expand (True) column.set_sort_column_id (1) self.view.append_column(column) col1 = gtk.TreeViewColumn (_("Last Modified"), gtk.CellRendererText(), text=self.COL_MODTIME) col1.set_resizable(True) col1.set_sort_column_id (2) self.view.append_column(col1) self.view.set_model (MapList.get_TreeViewModel()) self.view.set_search_column(self.COL_TITLE) self.view.set_enable_search (True) def sort_column_changed_cb (self, data): column_id, sort_order = data.get_sort_column_id () if os.name != 'nt': self.config_client.set_int('/apps/labyrinth/map_sort_order', sort_order) self.config_client.set_int('/apps/labyrinth/map_sort_order_column', column_id)

gpl-2.0

yotomyoto/benzene

tournament/program.py

5

3454

#---------------------------------------------------------------------------- # Connects to a Hex program. #---------------------------------------------------------------------------- import os, string, sys, subprocess from random import randrange from select import select #---------------------------------------------------------------------------- class Program: class CommandDenied(Exception): pass class Died(Exception): pass def __init__(self, color, command, logName, verbose): command = command.replace("%SRAND", `randrange(0, 1000000)`) self._command = command self._color = color self._verbose = verbose if self._verbose: print "Creating program:", command p = subprocess.Popen(command, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE); (self._stdin, self._stdout, self._stderr) = (p.stdin, p.stdout, p.stderr) self._isDead = 0 self._log = open(logName, "w") self._log.write("# " + self._command + "\n") def getColor(self): return self._color def getCommand(self): return self._command def getDenyReason(self): return self._denyReason def getName(self): name = "?" try: name = string.strip(self.sendCommand("name")) version = string.strip(self.sendCommand("version")) name += " " + version except Program.CommandDenied: pass return name def getResult(self): try: l = self.sendCommand("final_score") #s = string.split(l)[0] #return s return l.strip() except Program.CommandDenied: return "?" def getTimeRemaining(self): try: l = self.sendCommand("time_left"); return l.strip(); except Program.CommandDenied: return "?" def isDead(self): return self._isDead def sendCommand(self, cmd): try: self._log.write(">" + cmd + "\n") if self._verbose: print self._color + "< " + cmd self._stdin.write(cmd + "\n") self._stdin.flush() return self._getAnswer() except IOError: self._programDied() def _getAnswer(self): self._logStdErr() answer = "" done = 0 numberLines = 0 while not done: line = self._stdout.readline() if line == "": self._programDied() self._log.write("<" + line) if self._verbose: sys.stdout.write(self._color + "> " + line) numberLines += 1 done = (line == "\n") if not done: answer += line if answer[0] != '=': self._denyReason = string.strip(answer[2:]) raise Program.CommandDenied if numberLines == 1: return string.strip(answer[1:]) return answer[2:] def _logStdErr(self): list = select([self._stderr], [], [], 0)[0] for s in list: self._log.write(os.read(s.fileno(), 8192)) self._log.flush() def _programDied(self): self._isDead = 1 self._logStdErr() raise Program.Died

lgpl-3.0

jazcollins/models

domain_adaptation/domain_separation/dsn_eval.py

11

5759

# 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. # ============================================================================== # pylint: disable=line-too-long """Evaluation for Domain Separation Networks (DSNs).""" # pylint: enable=line-too-long import math import numpy as np import tensorflow as tf from domain_adaptation.datasets import dataset_factory from domain_adaptation.domain_separation import losses from domain_adaptation.domain_separation import models slim = tf.contrib.slim FLAGS = tf.app.flags.FLAGS tf.app.flags.DEFINE_integer('batch_size', 32, 'The number of images in each batch.') tf.app.flags.DEFINE_string('master', '', 'BNS name of the TensorFlow master to use.') tf.app.flags.DEFINE_string('checkpoint_dir', '/tmp/da/', 'Directory where the model was written to.') tf.app.flags.DEFINE_string( 'eval_dir', '/tmp/da/', 'Directory where we should write the tf summaries to.') tf.app.flags.DEFINE_string('dataset_dir', None, 'The directory where the dataset files are stored.') tf.app.flags.DEFINE_string('dataset', 'mnist_m', 'Which dataset to test on: "mnist", "mnist_m".') tf.app.flags.DEFINE_string('split', 'valid', 'Which portion to test on: "valid", "test".') tf.app.flags.DEFINE_integer('num_examples', 1000, 'Number of test examples.') tf.app.flags.DEFINE_string('basic_tower', 'dann_mnist', 'The basic tower building block.') tf.app.flags.DEFINE_bool('enable_precision_recall', False, 'If True, precision and recall for each class will ' 'be added to the metrics.') tf.app.flags.DEFINE_bool('use_logging', False, 'Debugging messages.') def quaternion_metric(predictions, labels): params = {'batch_size': FLAGS.batch_size, 'use_logging': False} logcost = losses.log_quaternion_loss_batch(predictions, labels, params) return slim.metrics.streaming_mean(logcost) def angle_diff(true_q, pred_q): angles = 2 * ( 180.0 / np.pi) * np.arccos(np.abs(np.sum(np.multiply(pred_q, true_q), axis=1))) return angles def provide_batch_fn(): """ The provide_batch function to use. """ return dataset_factory.provide_batch def main(_): g = tf.Graph() with g.as_default(): # Load the data. images, labels = provide_batch_fn()( FLAGS.dataset, FLAGS.split, FLAGS.dataset_dir, 4, FLAGS.batch_size, 4) num_classes = labels['classes'].get_shape().as_list()[1] tf.summary.image('eval_images', images, max_outputs=3) # Define the model: with tf.variable_scope('towers'): basic_tower = getattr(models, FLAGS.basic_tower) predictions, endpoints = basic_tower( images, num_classes=num_classes, is_training=False, batch_norm_params=None) metric_names_to_values = {} # Define the metrics: if 'quaternions' in labels: # Also have to evaluate pose estimation! quaternion_loss = quaternion_metric(labels['quaternions'], endpoints['quaternion_pred']) angle_errors, = tf.py_func( angle_diff, [labels['quaternions'], endpoints['quaternion_pred']], [tf.float32]) metric_names_to_values[ 'Angular mean error'] = slim.metrics.streaming_mean(angle_errors) metric_names_to_values['Quaternion Loss'] = quaternion_loss accuracy = tf.contrib.metrics.streaming_accuracy( tf.argmax(predictions, 1), tf.argmax(labels['classes'], 1)) predictions = tf.argmax(predictions, 1) labels = tf.argmax(labels['classes'], 1) metric_names_to_values['Accuracy'] = accuracy if FLAGS.enable_precision_recall: for i in xrange(num_classes): index_map = tf.one_hot(i, depth=num_classes) name = 'PR/Precision_{}'.format(i) metric_names_to_values[name] = slim.metrics.streaming_precision( tf.gather(index_map, predictions), tf.gather(index_map, labels)) name = 'PR/Recall_{}'.format(i) metric_names_to_values[name] = slim.metrics.streaming_recall( tf.gather(index_map, predictions), tf.gather(index_map, labels)) names_to_values, names_to_updates = slim.metrics.aggregate_metric_map( metric_names_to_values) # Create the summary ops such that they also print out to std output: summary_ops = [] for metric_name, metric_value in names_to_values.iteritems(): op = tf.summary.scalar(metric_name, metric_value) op = tf.Print(op, [metric_value], metric_name) summary_ops.append(op) # This ensures that we make a single pass over all of the data. num_batches = math.ceil(FLAGS.num_examples / float(FLAGS.batch_size)) # Setup the global step. slim.get_or_create_global_step() slim.evaluation.evaluation_loop( FLAGS.master, checkpoint_dir=FLAGS.checkpoint_dir, logdir=FLAGS.eval_dir, num_evals=num_batches, eval_op=names_to_updates.values(), summary_op=tf.summary.merge(summary_ops)) if __name__ == '__main__': tf.app.run()

apache-2.0

proxysh/Safejumper-for-Desktop

buildlinux/env32/lib/python2.7/site-packages/twisted/logger/test/test_global.py

12

9902

# Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.logger._global}. """ from __future__ import print_function import io from twisted.trial import unittest from .._file import textFileLogObserver from .._observer import LogPublisher from .._logger import Logger from .._global import LogBeginner from .._global import MORE_THAN_ONCE_WARNING from .._levels import LogLevel from ..test.test_stdlib import nextLine def compareEvents(test, actualEvents, expectedEvents): """ Compare two sequences of log events, examining only the the keys which are present in both. @param test: a test case doing the comparison @type test: L{unittest.TestCase} @param actualEvents: A list of log events that were emitted by a logger. @type actualEvents: L{list} of L{dict} @param expectedEvents: A list of log events that were expected by a test. @type expected: L{list} of L{dict} """ if len(actualEvents) != len(expectedEvents): test.assertEqual(actualEvents, expectedEvents) allMergedKeys = set() for event in expectedEvents: allMergedKeys |= set(event.keys()) def simplify(event): copy = event.copy() for key in event.keys(): if key not in allMergedKeys: copy.pop(key) return copy simplifiedActual = [simplify(event) for event in actualEvents] test.assertEqual(simplifiedActual, expectedEvents) class LogBeginnerTests(unittest.TestCase): """ Tests for L{LogBeginner}. """ def setUp(self): self.publisher = LogPublisher() self.errorStream = io.StringIO() class NotSys(object): stdout = object() stderr = object() class NotWarnings(object): def __init__(self): self.warnings = [] def showwarning( self, message, category, filename, lineno, file=None, line=None ): """ Emulate warnings.showwarning. @param message: A warning message to emit. @type message: L{str} @param category: A warning category to associate with C{message}. @type category: L{warnings.Warning} @param filename: A file name for the source code file issuing the warning. @type warning: L{str} @param lineno: A line number in the source file where the warning was issued. @type lineno: L{int} @param file: A file to write the warning message to. If L{None}, write to L{sys.stderr}. @type file: file-like object @param line: A line of source code to include with the warning message. If L{None}, attempt to read the line from C{filename} and C{lineno}. @type line: L{str} """ self.warnings.append( (message, category, filename, lineno, file, line) ) self.sysModule = NotSys() self.warningsModule = NotWarnings() self.beginner = LogBeginner( self.publisher, self.errorStream, self.sysModule, self.warningsModule ) def test_beginLoggingToAddObservers(self): """ Test that C{beginLoggingTo()} adds observers. """ event = dict(foo=1, bar=2) events1 = [] events2 = [] o1 = lambda e: events1.append(e) o2 = lambda e: events2.append(e) self.beginner.beginLoggingTo((o1, o2)) self.publisher(event) self.assertEqual([event], events1) self.assertEqual([event], events2) def test_beginLoggingToBufferedEvents(self): """ Test that events are buffered until C{beginLoggingTo()} is called. """ event = dict(foo=1, bar=2) events1 = [] events2 = [] o1 = lambda e: events1.append(e) o2 = lambda e: events2.append(e) self.publisher(event) # Before beginLoggingTo; this is buffered self.beginner.beginLoggingTo((o1, o2)) self.assertEqual([event], events1) self.assertEqual([event], events2) def test_beginLoggingToTwice(self): """ When invoked twice, L{LogBeginner.beginLoggingTo} will emit a log message warning the user that they previously began logging, and add the new log observers. """ events1 = [] events2 = [] fileHandle = io.StringIO() textObserver = textFileLogObserver(fileHandle) self.publisher(dict(event="prebuffer")) firstFilename, firstLine = nextLine() self.beginner.beginLoggingTo([events1.append, textObserver]) self.publisher(dict(event="postbuffer")) secondFilename, secondLine = nextLine() self.beginner.beginLoggingTo([events2.append, textObserver]) self.publisher(dict(event="postwarn")) warning = dict( log_format=MORE_THAN_ONCE_WARNING, log_level=LogLevel.warn, fileNow=secondFilename, lineNow=secondLine, fileThen=firstFilename, lineThen=firstLine ) compareEvents( self, events1, [ dict(event="prebuffer"), dict(event="postbuffer"), warning, dict(event="postwarn") ] ) compareEvents(self, events2, [warning, dict(event="postwarn")]) output = fileHandle.getvalue() self.assertIn('<{0}:{1}>'.format(firstFilename, firstLine), output) self.assertIn('<{0}:{1}>'.format(secondFilename, secondLine), output) def test_criticalLogging(self): """ Critical messages will be written as text to the error stream. """ log = Logger(observer=self.publisher) log.info("ignore this") log.critical("a critical {message}", message="message") self.assertEqual(self.errorStream.getvalue(), u"a critical message\n") def test_criticalLoggingStops(self): """ Once logging has begun with C{beginLoggingTo}, critical messages are no longer written to the output stream. """ log = Logger(observer=self.publisher) self.beginner.beginLoggingTo(()) log.critical("another critical message") self.assertEqual(self.errorStream.getvalue(), u"") def test_beginLoggingToRedirectStandardIO(self): """ L{LogBeginner.beginLoggingTo} will re-direct the standard output and error streams by setting the C{stdio} and C{stderr} attributes on its sys module object. """ x = [] self.beginner.beginLoggingTo([x.append]) print("Hello, world.", file=self.sysModule.stdout) compareEvents( self, x, [dict(log_namespace="stdout", log_io="Hello, world.")] ) del x[:] print("Error, world.", file=self.sysModule.stderr) compareEvents( self, x, [dict(log_namespace="stderr", log_io="Error, world.")] ) def test_beginLoggingToDontRedirect(self): """ L{LogBeginner.beginLoggingTo} will leave the existing stdout/stderr in place if it has been told not to replace them. """ oldOut = self.sysModule.stdout oldErr = self.sysModule.stderr self.beginner.beginLoggingTo((), redirectStandardIO=False) self.assertIs(self.sysModule.stdout, oldOut) self.assertIs(self.sysModule.stderr, oldErr) def test_beginLoggingToPreservesEncoding(self): """ When L{LogBeginner.beginLoggingTo} redirects stdout/stderr streams, the replacement streams will preserve the encoding of the replaced streams, to minimally disrupt any application relying on a specific encoding. """ weird = io.TextIOWrapper(io.BytesIO(), "shift-JIS") weirderr = io.TextIOWrapper(io.BytesIO(), "big5") self.sysModule.stdout = weird self.sysModule.stderr = weirderr x = [] self.beginner.beginLoggingTo([x.append]) self.assertEqual(self.sysModule.stdout.encoding, "shift-JIS") self.assertEqual(self.sysModule.stderr.encoding, "big5") self.sysModule.stdout.write(b"\x97\x9B\n") self.sysModule.stderr.write(b"\xBC\xFC\n") compareEvents( self, x, [dict(log_io=u"\u674e"), dict(log_io=u"\u7469")] ) def test_warningsModule(self): """ L{LogBeginner.beginLoggingTo} will redirect the warnings of its warnings module into the logging system. """ self.warningsModule.showwarning( "a message", DeprecationWarning, __file__, 1 ) x = [] self.beginner.beginLoggingTo([x.append]) self.warningsModule.showwarning( "another message", DeprecationWarning, __file__, 2 ) f = io.StringIO() self.warningsModule.showwarning( "yet another", DeprecationWarning, __file__, 3, file=f ) self.assertEqual( self.warningsModule.warnings, [ ("a message", DeprecationWarning, __file__, 1, None, None), ("yet another", DeprecationWarning, __file__, 3, f, None), ] ) compareEvents( self, x, [dict( warning="another message", category=( DeprecationWarning.__module__ + "." + DeprecationWarning.__name__ ), filename=__file__, lineno=2, )] )

gpl-2.0

ceos-seo/Data_Cube_v2

labs/dc_mosaicker.py

1

8894

# Copyright 2016 United States Government as represented by the Administrator # of the National Aeronautics and Space Administration. All Rights Reserved. # # Portion of this code is Copyright Geoscience Australia, 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 # # The CEOS 2 platform is licensed under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0. # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import numpy as np import xarray as xr import datacube import dc_utilities as utilities # Command line tool imports import argparse import os import collections import gdal from datetime import datetime # Author: KMF # Creation date: 2016-06-14 def create_mosaic(dataset_in, clean_mask=None, no_data=-9999): """ Description: Creates a most recent - oldest mosaic of the input dataset. If no clean mask is given, the 'cf_mask' variable must be included in the input dataset, as it will be used to create a clean mask ----- Inputs: dataset_in (xarray.Dataset) - dataset retrieved from the Data Cube; should contain coordinates: time, latitude, longitude variables: variables to be mosaicked If user does not provide a clean_mask, dataset_in must also include the cf_mask variable Optional Inputs: clean_mask (nd numpy array with dtype boolean) - true for values user considers clean; if user does not provide a clean mask, one will be created using cfmask no_data (int/float) - no data pixel value; default: -9999 Output: dataset_out (xarray.Dataset) - mosaicked data with coordinates: latitude, longitude variables: same as dataset_in """ # Create clean_mask from cfmask if none given if not clean_mask: cfmask = dataset_in.cf_mask clean_mask = utilities.create_cfmask_clean_mask(cfmask) data_vars = dataset_in.data_vars # Dict object with key as the name of the variable # and each value as the DataArray of that variable mosaic = collections.OrderedDict() # Dict to contain variable names as keys and # numpy arrays containing mosaicked data for key in data_vars: # Get raw data for current variable and mask the data data = data_vars[key].values masked = np.full(data.shape, no_data) masked[clean_mask] = data[clean_mask] out = np.full(masked.shape[1:], no_data) # Mosaic current variable (most recent - oldest) for index in reversed(range(len(clean_mask))): swap = np.reshape(np.in1d(out.reshape(-1), [no_data]), out.shape) out[swap] = masked[index][swap] mosaic[key] = (['latitude', 'longitude'], out) latitude = dataset_in.latitude longitude = dataset_in.longitude dataset_out = xr.Dataset(mosaic, coords={'latitude': latitude, 'longitude': longitude}) return dataset_out def main(platform, product_type, min_lon, max_lon, min_lat, max_lat, red, green, blue, start_date, end_date, dc_config): """ Description: Command-line mosaicking tool - creates a true color mosaic from the data retrieved by the Data Cube and save a GeoTIFF of the results Assumptions: The command-line tool assumes there is a measurement called cf_mask Inputs: platform (str) product_type (str) min_lon (str) max_lon (str) min_lat (str) max_lat (str) start_date (str) end_date (str) dc_config (str) """ # Initialize data cube object dc = datacube.Datacube(config=dc_config, app='dc-mosaicker') # Validate arguments products = dc.list_products() platform_names = set([product[6] for product in products.values]) if platform not in platform_names: print 'ERROR: Invalid platform.' print 'Valid platforms are:' for name in platform_names: print name return product_names = [product[0] for product in products.values] if product_type not in product_names: print 'ERROR: Invalid product type.' print 'Valid product types are:' for name in product_names: print name return measurements = dc.list_measurements() index_1 = measurements.keys()[0] # Doesn't matter what the actual value is, # just need to get into the next layer of the # DataFrame.. better way? bands = set(measurements[index_1][product_type].keys()) if not set([red, green, blue]).issubset(bands): print 'ERROR: Invalid product type.' print 'Valid product types are:' for band in bands: print band return try: min_lon = float(args.min_lon) max_lon = float(args.max_lon) min_lat = float(args.min_lat) max_lat = float(args.max_lat) except: print 'ERROR: Longitudes/Latitudes must be float values' return try: start_date_str = start_date end_date_str = end_date start_date = datetime.strptime(start_date, '%Y-%m-%d') end_date = datetime.strptime(end_date, '%Y-%m-%d') except: print 'ERROR: Invalid date format. Date format: YYYY-MM-DD' return if not os.path.exists(dc_config): print 'ERROR: Invalid file path for dc_config' return # Retrieve data from Data Cube dataset_in = dc.load(platform=platform, product=product_type, time=(start_date, end_date), lon=(min_lon, max_lon), lat=(min_lat, max_lat), measurements=[red, green, blue, 'cf_mask']) # Get information needed for saving as GeoTIFF # Spatial ref crs = dataset_in.crs spatial_ref = utilities.get_spatial_ref(crs) # Upper left coordinates ul_lon = dataset_in.longitude.values[0] ul_lat = dataset_in.latitude.values[0] # Resolution products = dc.list_products() resolution = products.resolution[products.name == 'ls7_ledaps'] lon_dist = resolution.values[0][1] lat_dist = resolution.values[0][0] # Rotation lon_rtn = 0 lat_rtn = 0 geotransform = (ul_lon, lon_dist, lon_rtn, ul_lat, lat_rtn, lat_dist) mosaic = create_mosaic(dataset_in) out_file = ( str(min_lon) + '_' + str(min_lat) + '_' + start_date_str + '_' + end_date_str + '_mosaic.tif' ) utilities.save_to_geotiff(out_file, gdal.GDT_Float32, mosaic, geotransform, spatial_ref) if __name__ == '__main__': start_time = datetime.now() parser = argparse.ArgumentParser() parser.add_argument('platform', help='Data platform; example: LANDSAT_7') parser.add_argument('product', help='Product type; example: ls7_ledaps') parser.add_argument('min_lon', help='Minimum longitude') parser.add_argument('max_lon', help='Maximum longitude') parser.add_argument('min_lat', help='Minimum latitude') parser.add_argument('max_lat', help='Maximum latitude') parser.add_argument('start_date', help='Start date; format: YYYY-MM-DD') parser.add_argument('end_date', help='End date; format: YYYY-MM-DD') parser.add_argument('red', nargs='?', default='red', help='Band to map to the red color channel') parser.add_argument('green', nargs='?', default='green', help='Band to map to the green color channel') parser.add_argument('blue', nargs='?', default='blue', help='Band to map to the blue color channel') parser.add_argument('dc_config', nargs='?', default='~/.datacube.conf', help='Datacube configuration path; default: ~/.datacube.conf') args = parser.parse_args() main(args.platform, args.product, args.min_lon, args.max_lon, args.min_lat, args.max_lat, args.red, args.green, args.blue, args.start_date, args.end_date, args.dc_config) end_time = datetime.now() print 'Execution time: ' + str(end_time - start_time)

apache-2.0

amitjamadagni/sympy

sympy/mpmath/functions/functions.py

6

17416

from ..libmp.backend import xrange class SpecialFunctions(object): """ This class implements special functions using high-level code. Elementary and some other functions (e.g. gamma function, basecase hypergeometric series) are assumed to be predefined by the context as "builtins" or "low-level" functions. """ defined_functions = {} # The series for the Jacobi theta functions converge for |q| < 1; # in the current implementation they throw a ValueError for # abs(q) > THETA_Q_LIM THETA_Q_LIM = 1 - 10**-7 def __init__(self): cls = self.__class__ for name in cls.defined_functions: f, wrap = cls.defined_functions[name] cls._wrap_specfun(name, f, wrap) self.mpq_1 = self._mpq((1,1)) self.mpq_0 = self._mpq((0,1)) self.mpq_1_2 = self._mpq((1,2)) self.mpq_3_2 = self._mpq((3,2)) self.mpq_1_4 = self._mpq((1,4)) self.mpq_1_16 = self._mpq((1,16)) self.mpq_3_16 = self._mpq((3,16)) self.mpq_5_2 = self._mpq((5,2)) self.mpq_3_4 = self._mpq((3,4)) self.mpq_7_4 = self._mpq((7,4)) self.mpq_5_4 = self._mpq((5,4)) self.mpq_1_3 = self._mpq((1,3)) self.mpq_2_3 = self._mpq((2,3)) self.mpq_4_3 = self._mpq((4,3)) self.mpq_1_6 = self._mpq((1,6)) self.mpq_5_6 = self._mpq((5,6)) self.mpq_5_3 = self._mpq((5,3)) self._misc_const_cache = {} self._aliases.update({ 'phase' : 'arg', 'conjugate' : 'conj', 'nthroot' : 'root', 'polygamma' : 'psi', 'hurwitz' : 'zeta', #'digamma' : 'psi0', #'trigamma' : 'psi1', #'tetragamma' : 'psi2', #'pentagamma' : 'psi3', 'fibonacci' : 'fib', 'factorial' : 'fac', }) self.zetazero_memoized = self.memoize(self.zetazero) # Default -- do nothing @classmethod def _wrap_specfun(cls, name, f, wrap): setattr(cls, name, f) # Optional fast versions of common functions in common cases. # If not overridden, default (generic hypergeometric series) # implementations will be used def _besselj(ctx, n, z): raise NotImplementedError def _erf(ctx, z): raise NotImplementedError def _erfc(ctx, z): raise NotImplementedError def _gamma_upper_int(ctx, z, a): raise NotImplementedError def _expint_int(ctx, n, z): raise NotImplementedError def _zeta(ctx, s): raise NotImplementedError def _zetasum_fast(ctx, s, a, n, derivatives, reflect): raise NotImplementedError def _ei(ctx, z): raise NotImplementedError def _e1(ctx, z): raise NotImplementedError def _ci(ctx, z): raise NotImplementedError def _si(ctx, z): raise NotImplementedError def _altzeta(ctx, s): raise NotImplementedError def defun_wrapped(f): SpecialFunctions.defined_functions[f.__name__] = f, True def defun(f): SpecialFunctions.defined_functions[f.__name__] = f, False def defun_static(f): setattr(SpecialFunctions, f.__name__, f) @defun_wrapped def cot(ctx, z): return ctx.one / ctx.tan(z) @defun_wrapped def sec(ctx, z): return ctx.one / ctx.cos(z) @defun_wrapped def csc(ctx, z): return ctx.one / ctx.sin(z) @defun_wrapped def coth(ctx, z): return ctx.one / ctx.tanh(z) @defun_wrapped def sech(ctx, z): return ctx.one / ctx.cosh(z) @defun_wrapped def csch(ctx, z): return ctx.one / ctx.sinh(z) @defun_wrapped def acot(ctx, z): return ctx.atan(ctx.one / z) @defun_wrapped def asec(ctx, z): return ctx.acos(ctx.one / z) @defun_wrapped def acsc(ctx, z): return ctx.asin(ctx.one / z) @defun_wrapped def acoth(ctx, z): return ctx.atanh(ctx.one / z) @defun_wrapped def asech(ctx, z): return ctx.acosh(ctx.one / z) @defun_wrapped def acsch(ctx, z): return ctx.asinh(ctx.one / z) @defun def sign(ctx, x): x = ctx.convert(x) if not x or ctx.isnan(x): return x if ctx._is_real_type(x): if x > 0: return ctx.one else: return -ctx.one return x / abs(x) @defun def agm(ctx, a, b=1): if b == 1: return ctx.agm1(a) a = ctx.convert(a) b = ctx.convert(b) return ctx._agm(a, b) @defun_wrapped def sinc(ctx, x): if ctx.isinf(x): return 1/x if not x: return x+1 return ctx.sin(x)/x @defun_wrapped def sincpi(ctx, x): if ctx.isinf(x): return 1/x if not x: return x+1 return ctx.sinpi(x)/(ctx.pi*x) # TODO: tests; improve implementation @defun_wrapped def expm1(ctx, x): if not x: return ctx.zero # exp(x) - 1 ~ x if ctx.mag(x) < -ctx.prec: return x + 0.5*x**2 # TODO: accurately eval the smaller of the real/imag parts return ctx.sum_accurately(lambda: iter([ctx.exp(x),-1]),1) @defun_wrapped def powm1(ctx, x, y): mag = ctx.mag one = ctx.one w = x**y - one M = mag(w) # Only moderate cancellation if M > -8: return w # Check for the only possible exact cases if not w: if (not y) or (x in (1, -1, 1j, -1j) and ctx.isint(y)): return w x1 = x - one magy = mag(y) lnx = ctx.ln(x) # Small y: x^y - 1 ~ log(x)*y + O(log(x)^2 * y^2) if magy + mag(lnx) < -ctx.prec: return lnx*y + (lnx*y)**2/2 # TODO: accurately eval the smaller of the real/imag part return ctx.sum_accurately(lambda: iter([x**y, -1]), 1) @defun def _rootof1(ctx, k, n): k = int(k) n = int(n) k %= n if not k: return ctx.one elif 2*k == n: return -ctx.one elif 4*k == n: return ctx.j elif 4*k == 3*n: return -ctx.j return ctx.expjpi(2*ctx.mpf(k)/n) @defun def root(ctx, x, n, k=0): n = int(n) x = ctx.convert(x) if k: # Special case: there is an exact real root if (n & 1 and 2*k == n-1) and (not ctx.im(x)) and (ctx.re(x) < 0): return -ctx.root(-x, n) # Multiply by root of unity prec = ctx.prec try: ctx.prec += 10 v = ctx.root(x, n, 0) * ctx._rootof1(k, n) finally: ctx.prec = prec return +v return ctx._nthroot(x, n) @defun def unitroots(ctx, n, primitive=False): gcd = ctx._gcd prec = ctx.prec try: ctx.prec += 10 if primitive: v = [ctx._rootof1(k,n) for k in range(n) if gcd(k,n) == 1] else: # TODO: this can be done *much* faster v = [ctx._rootof1(k,n) for k in range(n)] finally: ctx.prec = prec return [+x for x in v] @defun def arg(ctx, x): x = ctx.convert(x) re = ctx._re(x) im = ctx._im(x) return ctx.atan2(im, re) @defun def fabs(ctx, x): return abs(ctx.convert(x)) @defun def re(ctx, x): x = ctx.convert(x) if hasattr(x, "real"): # py2.5 doesn't have .real/.imag for all numbers return x.real return x @defun def im(ctx, x): x = ctx.convert(x) if hasattr(x, "imag"): # py2.5 doesn't have .real/.imag for all numbers return x.imag return ctx.zero @defun def conj(ctx, x): x = ctx.convert(x) try: return x.conjugate() except AttributeError: return x @defun def polar(ctx, z): return (ctx.fabs(z), ctx.arg(z)) @defun_wrapped def rect(ctx, r, phi): return r * ctx.mpc(*ctx.cos_sin(phi)) @defun def log(ctx, x, b=None): if b is None: return ctx.ln(x) wp = ctx.prec + 20 return ctx.ln(x, prec=wp) / ctx.ln(b, prec=wp) @defun def log10(ctx, x): return ctx.log(x, 10) @defun def fmod(ctx, x, y): return ctx.convert(x) % ctx.convert(y) @defun def degrees(ctx, x): return x / ctx.degree @defun def radians(ctx, x): return x * ctx.degree def _lambertw_special(ctx, z, k): # W(0,0) = 0; all other branches are singular if not z: if not k: return z return ctx.ninf + z if z == ctx.inf: if k == 0: return z else: return z + 2*k*ctx.pi*ctx.j if z == ctx.ninf: return (-z) + (2*k+1)*ctx.pi*ctx.j # Some kind of nan or complex inf/nan? return ctx.ln(z) import math import cmath def _lambertw_approx_hybrid(z, k): imag_sign = 0 if hasattr(z, "imag"): x = float(z.real) y = z.imag if y: imag_sign = (-1) ** (y < 0) y = float(y) else: x = float(z) y = 0.0 imag_sign = 0 # hack to work regardless of whether Python supports -0.0 if not y: y = 0.0 z = complex(x,y) if k == 0: if -4.0 < y < 4.0 and -1.0 < x < 2.5: if imag_sign: # Taylor series in upper/lower half-plane if y > 1.00: return (0.876+0.645j) + (0.118-0.174j)*(z-(0.75+2.5j)) if y > 0.25: return (0.505+0.204j) + (0.375-0.132j)*(z-(0.75+0.5j)) if y < -1.00: return (0.876-0.645j) + (0.118+0.174j)*(z-(0.75-2.5j)) if y < -0.25: return (0.505-0.204j) + (0.375+0.132j)*(z-(0.75-0.5j)) # Taylor series near -1 if x < -0.5: if imag_sign >= 0: return (-0.318+1.34j) + (-0.697-0.593j)*(z+1) else: return (-0.318-1.34j) + (-0.697+0.593j)*(z+1) # return real type r = -0.367879441171442 if (not imag_sign) and x > r: z = x # Singularity near -1/e if x < -0.2: return -1 + 2.33164398159712*(z-r)**0.5 - 1.81218788563936*(z-r) # Taylor series near 0 if x < 0.5: return z # Simple linear approximation return 0.2 + 0.3*z if (not imag_sign) and x > 0.0: L1 = math.log(x) L2 = math.log(L1) else: L1 = cmath.log(z) L2 = cmath.log(L1) elif k == -1: # return real type r = -0.367879441171442 if (not imag_sign) and r < x < 0.0: z = x if (imag_sign >= 0) and y < 0.1 and -0.6 < x < -0.2: return -1 - 2.33164398159712*(z-r)**0.5 - 1.81218788563936*(z-r) if (not imag_sign) and -0.2 <= x < 0.0: L1 = math.log(-x) return L1 - math.log(-L1) else: if imag_sign == -1 and (not y) and x < 0.0: L1 = cmath.log(z) - 3.1415926535897932j else: L1 = cmath.log(z) - 6.2831853071795865j L2 = cmath.log(L1) return L1 - L2 + L2/L1 + L2*(L2-2)/(2*L1**2) def _lambertw_series(ctx, z, k, tol): """ Return rough approximation for W_k(z) from an asymptotic series, sufficiently accurate for the Halley iteration to converge to the correct value. """ magz = ctx.mag(z) if (-10 < magz < 900) and (-1000 < k < 1000): # Near the branch point at -1/e if magz < 1 and abs(z+0.36787944117144) < 0.05: if k == 0 or (k == -1 and ctx._im(z) >= 0) or \ (k == 1 and ctx._im(z) < 0): delta = ctx.sum_accurately(lambda: [z, ctx.exp(-1)]) cancellation = -ctx.mag(delta) ctx.prec += cancellation # Use series given in Corless et al. p = ctx.sqrt(2*(ctx.e*z+1)) ctx.prec -= cancellation u = {0:ctx.mpf(-1), 1:ctx.mpf(1)} a = {0:ctx.mpf(2), 1:ctx.mpf(-1)} if k != 0: p = -p s = ctx.zero # The series converges, so we could use it directly, but unless # *extremely* close, it is better to just use the first few # terms to get a good approximation for the iteration for l in xrange(max(2,cancellation)): if l not in u: a[l] = ctx.fsum(u[j]*u[l+1-j] for j in xrange(2,l)) u[l] = (l-1)*(u[l-2]/2+a[l-2]/4)/(l+1)-a[l]/2-u[l-1]/(l+1) term = u[l] * p**l s += term if ctx.mag(term) < -tol: return s, True l += 1 ctx.prec += cancellation//2 return s, False if k == 0 or k == -1: return _lambertw_approx_hybrid(z, k), False if k == 0: if magz < -1: return z*(1-z), False L1 = ctx.ln(z) L2 = ctx.ln(L1) elif k == -1 and (not ctx._im(z)) and (-0.36787944117144 < ctx._re(z) < 0): L1 = ctx.ln(-z) return L1 - ctx.ln(-L1), False else: # This holds both as z -> 0 and z -> inf. # Relative error is O(1/log(z)). L1 = ctx.ln(z) + 2j*ctx.pi*k L2 = ctx.ln(L1) return L1 - L2 + L2/L1 + L2*(L2-2)/(2*L1**2), False @defun def lambertw(ctx, z, k=0): z = ctx.convert(z) k = int(k) if not ctx.isnormal(z): return _lambertw_special(ctx, z, k) prec = ctx.prec ctx.prec += 20 + ctx.mag(k or 1) wp = ctx.prec tol = wp - 5 w, done = _lambertw_series(ctx, z, k, tol) if not done: # Use Halley iteration to solve w*exp(w) = z two = ctx.mpf(2) for i in xrange(100): ew = ctx.exp(w) wew = w*ew wewz = wew-z wn = w - wewz/(wew+ew-(w+two)*wewz/(two*w+two)) if ctx.mag(wn-w) <= ctx.mag(wn) - tol: w = wn break else: w = wn if i == 100: ctx.warn("Lambert W iteration failed to converge for z = %s" % z) ctx.prec = prec return +w @defun_wrapped def bell(ctx, n, x=1): x = ctx.convert(x) if not n: if ctx.isnan(x): return x return type(x)(1) if ctx.isinf(x) or ctx.isinf(n) or ctx.isnan(x) or ctx.isnan(n): return x**n if n == 1: return x if n == 2: return x*(x+1) if x == 0: return ctx.sincpi(n) return _polyexp(ctx, n, x, True) / ctx.exp(x) def _polyexp(ctx, n, x, extra=False): def _terms(): if extra: yield ctx.sincpi(n) t = x k = 1 while 1: yield k**n * t k += 1 t = t*x/k return ctx.sum_accurately(_terms, check_step=4) @defun_wrapped def polyexp(ctx, s, z): if ctx.isinf(z) or ctx.isinf(s) or ctx.isnan(z) or ctx.isnan(s): return z**s if z == 0: return z*s if s == 0: return ctx.expm1(z) if s == 1: return ctx.exp(z)*z if s == 2: return ctx.exp(z)*z*(z+1) return _polyexp(ctx, s, z) @defun_wrapped def cyclotomic(ctx, n, z): n = int(n) assert n >= 0 p = ctx.one if n == 0: return p if n == 1: return z - p if n == 2: return z + p # Use divisor product representation. Unfortunately, this sometimes # includes singularities for roots of unity, which we have to cancel out. # Matching zeros/poles pairwise, we have (1-z^a)/(1-z^b) ~ a/b + O(z-1). a_prod = 1 b_prod = 1 num_zeros = 0 num_poles = 0 for d in range(1,n+1): if not n % d: w = ctx.moebius(n//d) # Use powm1 because it is important that we get 0 only # if it really is exactly 0 b = -ctx.powm1(z, d) if b: p *= b**w else: if w == 1: a_prod *= d num_zeros += 1 elif w == -1: b_prod *= d num_poles += 1 #print n, num_zeros, num_poles if num_zeros: if num_zeros > num_poles: p *= 0 else: p *= a_prod p /= b_prod return p @defun def mangoldt(ctx, n): r""" Evaluates the von Mangoldt function `\Lambda(n) = \log p` if `n = p^k` a power of a prime, and `\Lambda(n) = 0` otherwise. **Examples** >>> from mpmath import * >>> mp.dps = 25; mp.pretty = True >>> [mangoldt(n) for n in range(-2,3)] [0.0, 0.0, 0.0, 0.0, 0.6931471805599453094172321] >>> mangoldt(6) 0.0 >>> mangoldt(7) 1.945910149055313305105353 >>> mangoldt(8) 0.6931471805599453094172321 >>> fsum(mangoldt(n) for n in range(101)) 94.04531122935739224600493 >>> fsum(mangoldt(n) for n in range(10001)) 10013.39669326311478372032 """ n = int(n) if n < 2: return ctx.zero if n % 2 == 0: # Must be a power of two if n & (n-1) == 0: return +ctx.ln2 else: return ctx.zero # TODO: the following could be generalized into a perfect # power testing function # --- # Look for a small factor for p in (3,5,7,11,13,17,19,23,29,31): if not n % p: q, r = n // p, 0 while q > 1: q, r = divmod(q, p) if r: return ctx.zero return ctx.ln(p) if ctx.isprime(n): return ctx.ln(n) # Obviously, we could use arbitrary-precision arithmetic for this... if n > 10**30: raise NotImplementedError k = 2 while 1: p = int(n**(1./k) + 0.5) if p < 2: return ctx.zero if p ** k == n: if ctx.isprime(p): return ctx.ln(p) k += 1

bsd-3-clause

ageitgey/face_recognition

examples/benchmark.py

1

2450

import timeit # Note: This example is only tested with Python 3 (not Python 2) # This is a very simple benchmark to give you an idea of how fast each step of face recognition will run on your system. # Notice that face detection gets very slow at large image sizes. So you might consider running face detection on a # scaled down version of your image and then running face encodings on the the full size image. TEST_IMAGES = [ "obama-240p.jpg", "obama-480p.jpg", "obama-720p.jpg", "obama-1080p.jpg" ] def run_test(setup, test, iterations_per_test=5, tests_to_run=10): fastest_execution = min(timeit.Timer(test, setup=setup).repeat(tests_to_run, iterations_per_test)) execution_time = fastest_execution / iterations_per_test fps = 1.0 / execution_time return execution_time, fps setup_locate_faces = """ import face_recognition image = face_recognition.load_image_file("{}") """ test_locate_faces = """ face_locations = face_recognition.face_locations(image) """ setup_face_landmarks = """ import face_recognition image = face_recognition.load_image_file("{}") face_locations = face_recognition.face_locations(image) """ test_face_landmarks = """ landmarks = face_recognition.face_landmarks(image, face_locations=face_locations)[0] """ setup_encode_face = """ import face_recognition image = face_recognition.load_image_file("{}") face_locations = face_recognition.face_locations(image) """ test_encode_face = """ encoding = face_recognition.face_encodings(image, known_face_locations=face_locations)[0] """ setup_end_to_end = """ import face_recognition image = face_recognition.load_image_file("{}") """ test_end_to_end = """ encoding = face_recognition.face_encodings(image)[0] """ print("Benchmarks (Note: All benchmarks are only using a single CPU core)") print() for image in TEST_IMAGES: size = image.split("-")[1].split(".")[0] print("Timings at {}:".format(size)) print(" - Face locations: {:.4f}s ({:.2f} fps)".format(*run_test(setup_locate_faces.format(image), test_locate_faces))) print(" - Face landmarks: {:.4f}s ({:.2f} fps)".format(*run_test(setup_face_landmarks.format(image), test_face_landmarks))) print(" - Encode face (inc. landmarks): {:.4f}s ({:.2f} fps)".format(*run_test(setup_encode_face.format(image), test_encode_face))) print(" - End-to-end: {:.4f}s ({:.2f} fps)".format(*run_test(setup_end_to_end.format(image), test_end_to_end))) print()

mit

PhiInnovations/mdp28-linux-bsp

openembedded-core/meta/lib/oe/packagedata.py

2

3067

import codecs def packaged(pkg, d): return os.access(get_subpkgedata_fn(pkg, d) + '.packaged', os.R_OK) def read_pkgdatafile(fn): pkgdata = {} def decode(str): c = codecs.getdecoder("string_escape") return c(str)[0] if os.access(fn, os.R_OK): import re f = file(fn, 'r') lines = f.readlines() f.close() r = re.compile("([^:]+):\s*(.*)") for l in lines: m = r.match(l) if m: pkgdata[m.group(1)] = decode(m.group(2)) return pkgdata def all_pkgdatadirs(d): dirs = [] triplets = (d.getVar("PKGMLTRIPLETS") or "").split() for t in triplets: dirs.append(t + "/runtime/") return dirs def get_subpkgedata_fn(pkg, d): dirs = all_pkgdatadirs(d) pkgdata = d.expand('${TMPDIR}/pkgdata/') for dir in dirs: fn = pkgdata + dir + pkg if os.path.exists(fn): return fn return d.expand('${PKGDATA_DIR}/runtime/%s' % pkg) def has_subpkgdata(pkg, d): return os.access(get_subpkgedata_fn(pkg, d), os.R_OK) def read_subpkgdata(pkg, d): return read_pkgdatafile(get_subpkgedata_fn(pkg, d)) def has_pkgdata(pn, d): fn = d.expand('${PKGDATA_DIR}/%s' % pn) return os.access(fn, os.R_OK) def read_pkgdata(pn, d): fn = d.expand('${PKGDATA_DIR}/%s' % pn) return read_pkgdatafile(fn) # # Collapse FOO_pkg variables into FOO # def read_subpkgdata_dict(pkg, d): ret = {} subd = read_pkgdatafile(get_subpkgedata_fn(pkg, d)) for var in subd: newvar = var.replace("_" + pkg, "") if newvar == var and var + "_" + pkg in subd: continue ret[newvar] = subd[var] return ret def _pkgmap(d): """Return a dictionary mapping package to recipe name.""" target_os = d.getVar("TARGET_OS", True) target_vendor = d.getVar("TARGET_VENDOR", True) basedir = os.path.dirname(d.getVar("PKGDATA_DIR", True)) dirs = ("%s%s-%s" % (arch, target_vendor, target_os) for arch in d.getVar("PACKAGE_ARCHS", True).split()) pkgmap = {} for pkgdatadir in (os.path.join(basedir, sys) for sys in dirs): try: files = os.listdir(pkgdatadir) except OSError: continue for pn in filter(lambda f: not os.path.isdir(os.path.join(pkgdatadir, f)), files): try: pkgdata = read_pkgdatafile(os.path.join(pkgdatadir, pn)) except OSError: continue packages = pkgdata.get("PACKAGES") or "" for pkg in packages.split(): pkgmap[pkg] = pn return pkgmap def pkgmap(d): """Return a dictionary mapping package to recipe name. Cache the mapping in the metadata""" pkgmap_data = d.getVar("__pkgmap_data", False) if pkgmap_data is None: pkgmap_data = _pkgmap(d) d.setVar("__pkgmap_data", pkgmap_data) return pkgmap_data def recipename(pkg, d): """Return the recipe name for the given binary package name.""" return pkgmap(d).get(pkg)

mit

alimony/django

django/contrib/postgres/forms/array.py

6

6964

import copy from itertools import chain from django import forms from django.contrib.postgres.validators import ( ArrayMaxLengthValidator, ArrayMinLengthValidator, ) from django.core.exceptions import ValidationError from django.utils.translation import gettext_lazy as _ from ..utils import prefix_validation_error class SimpleArrayField(forms.CharField): default_error_messages = { 'item_invalid': _('Item %(nth)s in the array did not validate: '), } def __init__(self, base_field, delimiter=',', max_length=None, min_length=None, *args, **kwargs): self.base_field = base_field self.delimiter = delimiter super().__init__(*args, **kwargs) if min_length is not None: self.min_length = min_length self.validators.append(ArrayMinLengthValidator(int(min_length))) if max_length is not None: self.max_length = max_length self.validators.append(ArrayMaxLengthValidator(int(max_length))) def prepare_value(self, value): if isinstance(value, list): return self.delimiter.join(str(self.base_field.prepare_value(v)) for v in value) return value def to_python(self, value): if isinstance(value, list): items = value elif value: items = value.split(self.delimiter) else: items = [] errors = [] values = [] for index, item in enumerate(items): try: values.append(self.base_field.to_python(item)) except ValidationError as error: errors.append(prefix_validation_error( error, prefix=self.error_messages['item_invalid'], code='item_invalid', params={'nth': index}, )) if errors: raise ValidationError(errors) return values def validate(self, value): super().validate(value) errors = [] for index, item in enumerate(value): try: self.base_field.validate(item) except ValidationError as error: errors.append(prefix_validation_error( error, prefix=self.error_messages['item_invalid'], code='item_invalid', params={'nth': index}, )) if errors: raise ValidationError(errors) def run_validators(self, value): super().run_validators(value) errors = [] for index, item in enumerate(value): try: self.base_field.run_validators(item) except ValidationError as error: errors.append(prefix_validation_error( error, prefix=self.error_messages['item_invalid'], code='item_invalid', params={'nth': index}, )) if errors: raise ValidationError(errors) class SplitArrayWidget(forms.Widget): template_name = 'postgres/widgets/split_array.html' def __init__(self, widget, size, **kwargs): self.widget = widget() if isinstance(widget, type) else widget self.size = size super().__init__(**kwargs) @property def is_hidden(self): return self.widget.is_hidden def value_from_datadict(self, data, files, name): return [self.widget.value_from_datadict(data, files, '%s_%s' % (name, index)) for index in range(self.size)] def value_omitted_from_data(self, data, files, name): return all( self.widget.value_omitted_from_data(data, files, '%s_%s' % (name, index)) for index in range(self.size) ) def id_for_label(self, id_): # See the comment for RadioSelect.id_for_label() if id_: id_ += '_0' return id_ def get_context(self, name, value, attrs=None): attrs = {} if attrs is None else attrs context = super().get_context(name, value, attrs) if self.is_localized: self.widget.is_localized = self.is_localized value = value or [] context['widget']['subwidgets'] = [] final_attrs = self.build_attrs(attrs) id_ = final_attrs.get('id') for i in range(max(len(value), self.size)): try: widget_value = value[i] except IndexError: widget_value = None if id_: final_attrs = dict(final_attrs, id='%s_%s' % (id_, i)) context['widget']['subwidgets'].append( self.widget.get_context(name + '_%s' % i, widget_value, final_attrs)['widget'] ) return context @property def media(self): return self.widget.media def __deepcopy__(self, memo): obj = super().__deepcopy__(memo) obj.widget = copy.deepcopy(self.widget) return obj @property def needs_multipart_form(self): return self.widget.needs_multipart_form class SplitArrayField(forms.Field): default_error_messages = { 'item_invalid': _('Item %(nth)s in the array did not validate: '), } def __init__(self, base_field, size, remove_trailing_nulls=False, **kwargs): self.base_field = base_field self.size = size self.remove_trailing_nulls = remove_trailing_nulls widget = SplitArrayWidget(widget=base_field.widget, size=size) kwargs.setdefault('widget', widget) super().__init__(**kwargs) def clean(self, value): cleaned_data = [] errors = [] if not any(value) and self.required: raise ValidationError(self.error_messages['required']) max_size = max(self.size, len(value)) for index in range(max_size): item = value[index] try: cleaned_data.append(self.base_field.clean(item)) except ValidationError as error: errors.append(prefix_validation_error( error, self.error_messages['item_invalid'], code='item_invalid', params={'nth': index}, )) cleaned_data.append(None) else: errors.append(None) if self.remove_trailing_nulls: null_index = None for i, value in reversed(list(enumerate(cleaned_data))): if value in self.base_field.empty_values: null_index = i else: break if null_index is not None: cleaned_data = cleaned_data[:null_index] errors = errors[:null_index] errors = list(filter(None, errors)) if errors: raise ValidationError(list(chain.from_iterable(errors))) return cleaned_data

bsd-3-clause

sein-tao/trash-cli

unit_tests/test_list_all_trashinfo_contents.py

2

1611

from mock import Mock, call from nose.tools import assert_equals, assert_items_equal class TestListing: def setUp(self): self.trashdir = Mock() self.trashinfo_reader = Mock() self.listing = Listing(self.trashdir, self.trashinfo_reader) def test_it_should_read_all_trashinfo_from_home_dir(self): self.listing.read_home_trashdir('/path/to/trash_dir') self.trashdir.list_trashinfos.assert_called_with( trashdir='/path/to/trash_dir', list_to=self.trashinfo_reader) class TestTrashDirReader: def test_should_list_all_trashinfo_found(self): def files(path): yield 'file1'; yield 'file2' os_listdir = Mock(side_effect=files) trashdir = TrashDirReader(os_listdir) out = Mock() trashdir.list_trashinfos(trashdir='/path', list_to=out) assert_items_equal([call(trashinfo='/path/file1'), call(trashinfo='/path/file2')], out.mock_calls) class TrashDirReader: def __init__(self, os_listdir): self.os_listdir = os_listdir def list_trashinfos(self, trashdir, list_to): import os for entry in self.os_listdir(trashdir): full_path = os.path.join(trashdir, entry) list_to(trashinfo=full_path) class Listing: def __init__(self, trashdir, trashinfo_reader): self.trashdir = trashdir self.trashinfo_reader = trashinfo_reader def read_home_trashdir(self, path): self.trashdir.list_trashinfos(trashdir=path, list_to=self.trashinfo_reader)

gpl-2.0

ubuntu-core/snapcraft

tests/spread/plugins/v1/x-local/snaps/from-nilplugin/snap/plugins/x_local_plugin.py

1

1166

# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*- # # Copyright (C) 2020 Canonical Ltd # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License version 3 as # published by the Free Software Foundation. # # This program 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 General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from snapcraft.plugins import nil class LocalPlugin(nil.NilPlugin): @classmethod def schema(cls): schema = super().schema() schema["properties"]["foo"] = {"type": "string"} return schema @classmethod def get_pull_properties(cls): return ["foo", "stage-packages"] @classmethod def get_build_properties(cls): return ["foo", "stage-packages"] def build(self): return self.run(["touch", "build-stamp"], self.installdir)

gpl-3.0

sergiorb/askkit

allauth/account/utils.py

11

13863

from datetime import timedelta try: from django.utils.timezone import now except ImportError: from datetime import datetime now = datetime.now import django from django.contrib import messages from django.core.urlresolvers import reverse from django.conf import settings from django.http import HttpResponseRedirect from django.utils import six from django.utils.http import urlencode from django.utils.http import int_to_base36, base36_to_int from django.core.exceptions import ValidationError if django.VERSION > (1, 8,): from collections import OrderedDict else: from django.utils.datastructures import SortedDict as OrderedDict try: from django.utils.encoding import force_text except ImportError: from django.utils.encoding import force_unicode as force_text from ..exceptions import ImmediateHttpResponse from ..utils import (import_callable, valid_email_or_none, get_user_model, get_request_param) from . import signals from .app_settings import EmailVerificationMethod from . import app_settings from .adapter import get_adapter def get_next_redirect_url(request, redirect_field_name="next"): """ Returns the next URL to redirect to, if it was explicitly passed via the request. """ redirect_to = get_request_param(request, redirect_field_name) if not get_adapter().is_safe_url(redirect_to): redirect_to = None return redirect_to def get_login_redirect_url(request, url=None, redirect_field_name="next"): redirect_url \ = (url or get_next_redirect_url(request, redirect_field_name=redirect_field_name) or get_adapter().get_login_redirect_url(request)) return redirect_url _user_display_callable = None def default_user_display(user): if app_settings.USER_MODEL_USERNAME_FIELD: return getattr(user, app_settings.USER_MODEL_USERNAME_FIELD) else: return force_text(user) def user_display(user): global _user_display_callable if not _user_display_callable: f = getattr(settings, "ACCOUNT_USER_DISPLAY", default_user_display) _user_display_callable = import_callable(f) return _user_display_callable(user) def user_field(user, field, *args): """ Gets or sets (optional) user model fields. No-op if fields do not exist. """ if field and hasattr(user, field): if args: # Setter v = args[0] if v: User = get_user_model() v = v[0:User._meta.get_field(field).max_length] setattr(user, field, v) else: # Getter return getattr(user, field) def user_username(user, *args): return user_field(user, app_settings.USER_MODEL_USERNAME_FIELD, *args) def user_email(user, *args): return user_field(user, app_settings.USER_MODEL_EMAIL_FIELD, *args) def perform_login(request, user, email_verification, redirect_url=None, signal_kwargs=None, signup=False): """ Keyword arguments: signup -- Indicates whether or not sending the email is essential (during signup), or if it can be skipped (e.g. in case email verification is optional and we are only logging in). """ # Local users are stopped due to form validation checking # is_active, yet, adapter methods could toy with is_active in a # `user_signed_up` signal. Furthermore, social users should be # stopped anyway. if not user.is_active: return HttpResponseRedirect(reverse('account_inactive')) from .models import EmailAddress has_verified_email = EmailAddress.objects.filter(user=user, verified=True).exists() if email_verification == EmailVerificationMethod.NONE: pass elif email_verification == EmailVerificationMethod.OPTIONAL: # In case of OPTIONAL verification: send on signup. if not has_verified_email and signup: send_email_confirmation(request, user, signup=signup) elif email_verification == EmailVerificationMethod.MANDATORY: if not has_verified_email: send_email_confirmation(request, user, signup=signup) return HttpResponseRedirect( reverse('account_email_verification_sent')) try: get_adapter().login(request, user) response = HttpResponseRedirect( get_login_redirect_url(request, redirect_url)) if signal_kwargs is None: signal_kwargs = {} signals.user_logged_in.send(sender=user.__class__, request=request, response=response, user=user, **signal_kwargs) get_adapter().add_message(request, messages.SUCCESS, 'account/messages/logged_in.txt', {'user': user}) except ImmediateHttpResponse as e: response = e.response return response def complete_signup(request, user, email_verification, success_url, signal_kwargs=None): if signal_kwargs is None: signal_kwargs = {} signals.user_signed_up.send(sender=user.__class__, request=request, user=user, **signal_kwargs) return perform_login(request, user, email_verification=email_verification, signup=True, redirect_url=success_url, signal_kwargs=signal_kwargs) def cleanup_email_addresses(request, addresses): """ Takes a list of EmailAddress instances and cleans it up, making sure only valid ones remain, without multiple primaries etc. Order is important: e.g. if multiple primary e-mail addresses exist, the first one encountered will be kept as primary. """ from .models import EmailAddress adapter = get_adapter() # Let's group by `email` e2a = OrderedDict() # maps email to EmailAddress primary_addresses = [] verified_addresses = [] primary_verified_addresses = [] for address in addresses: # Pick up only valid ones... email = valid_email_or_none(address.email) if not email: continue # ... and non-conflicting ones... if (app_settings.UNIQUE_EMAIL and EmailAddress.objects .filter(email__iexact=email) .exists()): continue a = e2a.get(email.lower()) if a: a.primary = a.primary or address.primary a.verified = a.verified or address.verified else: a = address a.verified = a.verified or adapter.is_email_verified(request, a.email) e2a[email.lower()] = a if a.primary: primary_addresses.append(a) if a.verified: primary_verified_addresses.append(a) if a.verified: verified_addresses.append(a) # Now that we got things sorted out, let's assign a primary if primary_verified_addresses: primary_address = primary_verified_addresses[0] elif verified_addresses: # Pick any verified as primary primary_address = verified_addresses[0] elif primary_addresses: # Okay, let's pick primary then, even if unverified primary_address = primary_addresses[0] elif e2a: # Pick the first primary_address = e2a.keys()[0] else: # Empty primary_address = None # There can only be one primary for a in e2a.values(): a.primary = primary_address.email.lower() == a.email.lower() return list(e2a.values()), primary_address def setup_user_email(request, user, addresses): """ Creates proper EmailAddress for the user that was just signed up. Only sets up, doesn't do any other handling such as sending out email confirmation mails etc. """ from .models import EmailAddress assert EmailAddress.objects.filter(user=user).count() == 0 priority_addresses = [] # Is there a stashed e-mail? adapter = get_adapter() stashed_email = adapter.unstash_verified_email(request) if stashed_email: priority_addresses.append(EmailAddress(user=user, email=stashed_email, primary=True, verified=True)) email = user_email(user) if email: priority_addresses.append(EmailAddress(user=user, email=email, primary=True, verified=False)) addresses, primary = cleanup_email_addresses(request, priority_addresses + addresses) for a in addresses: a.user = user a.save() EmailAddress.objects.fill_cache_for_user(user, addresses) if (primary and email and email.lower() != primary.email.lower()): user_email(user, primary.email) user.save() return primary def send_email_confirmation(request, user, signup=False): """ E-mail verification mails are sent: a) Explicitly: when a user signs up b) Implicitly: when a user attempts to log in using an unverified e-mail while EMAIL_VERIFICATION is mandatory. Especially in case of b), we want to limit the number of mails sent (consider a user retrying a few times), which is why there is a cooldown period before sending a new mail. """ from .models import EmailAddress, EmailConfirmation COOLDOWN_PERIOD = timedelta(minutes=3) email = user_email(user) if email: try: email_address = EmailAddress.objects.get_for_user(user, email) if not email_address.verified: send_email = not EmailConfirmation.objects \ .filter(sent__gt=now() - COOLDOWN_PERIOD, email_address=email_address) \ .exists() if send_email: email_address.send_confirmation(request, signup=signup) else: send_email = False except EmailAddress.DoesNotExist: send_email = True email_address = EmailAddress.objects.add_email(request, user, email, signup=signup, confirm=True) assert email_address # At this point, if we were supposed to send an email we have sent it. if send_email: get_adapter().add_message(request, messages.INFO, 'account/messages/' 'email_confirmation_sent.txt', {'email': email}) if signup: request.session['account_user'] = user.pk def sync_user_email_addresses(user): """ Keep user.email in sync with user.emailaddress_set. Under some circumstances the user.email may not have ended up as an EmailAddress record, e.g. in the case of manually created admin users. """ from .models import EmailAddress email = user_email(user) if email and not EmailAddress.objects.filter(user=user, email__iexact=email).exists(): if app_settings.UNIQUE_EMAIL \ and EmailAddress.objects.filter(email__iexact=email).exists(): # Bail out return EmailAddress.objects.create(user=user, email=email, primary=False, verified=False) def filter_users_by_email(email): """Return list of users by email address Typically one, at most just a few in length. First we look through EmailAddress table, than customisable User model table. Add results together avoiding SQL joins and deduplicate. """ from .models import EmailAddress User = get_user_model() mails = EmailAddress.objects.filter(email__iexact=email) users = [e.user for e in mails.prefetch_related('user')] if app_settings.USER_MODEL_EMAIL_FIELD: q_dict = {app_settings.USER_MODEL_EMAIL_FIELD + '__iexact': email} users += list(User.objects.filter(**q_dict)) return list(set(users)) def passthrough_next_redirect_url(request, url, redirect_field_name): assert url.find("?") < 0 # TODO: Handle this case properly next_url = get_next_redirect_url(request, redirect_field_name) if next_url: url = url + '?' + urlencode({redirect_field_name: next_url}) return url def user_pk_to_url_str(user): ret = user.pk if isinstance(ret, six.integer_types): ret = int_to_base36(user.pk) return ret def url_str_to_user_pk(s): User = get_user_model() # TODO: Ugh, isn't there a cleaner way to determine whether or not # the PK is a str-like field? try: User._meta.pk.to_python('a') pk = s except ValidationError: pk = base36_to_int(s) return pk

apache-2.0

unlimitedlabs/orchestra

orchestra/bots/tests/test_basebot.py

2

2810

from orchestra.bots.basebot import BaseBot from orchestra.bots.errors import SlackCommandInvalidRequest from orchestra.bots.tests.fixtures import get_mock_slack_data from orchestra.tests.helpers import OrchestraTestCase class BaseBotTest(OrchestraTestCase): token = get_mock_slack_data().get('token') def test_help(self): bot = BaseBot(self.token) mock_slack_data = get_mock_slack_data(text='help') with self.assertRaises(NotImplementedError): bot.dispatch(mock_slack_data) def test_validate(self): """ Ensure we only listen to valid requests. """ mock_slack_data = get_mock_slack_data() # Test all requests allowed bot = BaseBot(self.token) self.assertEqual(mock_slack_data, bot.validate(mock_slack_data)) # verify we validate the token bot = BaseBot('') with self.assertRaises(SlackCommandInvalidRequest): bot.validate(mock_slack_data) # verify that we perform validation on each of the fields validated_fields = ['allowed_team_ids', 'allowed_domains', 'allowed_channel_ids', 'allowed_channel_names', 'allowed_user_ids', 'allowed_user_names', 'allowed_commands'] for field in validated_fields: config = {field: []} bot = BaseBot(self.token, **config) with self.assertRaises(SlackCommandInvalidRequest): bot.validate(mock_slack_data) config = {'allowed_{}s'.format(field): [mock_slack_data.get(field)] for field in validated_fields} bot = BaseBot(self.token, **config) self.assertEqual(mock_slack_data, bot.validate(mock_slack_data)) def test_dispatch(self): bot = BaseBot(self.token) bot.commands = ( (r'test_command (?P<test_param>[0-9]+)', 'test_command'), ) def test_command(test_param): return test_param bot.test_command = test_command # Assign the testing command bot.__init__(self.token) # Test a valid command text = 'test_command 5' mock_slack_data = get_mock_slack_data(text=text) result = bot.dispatch(mock_slack_data) self.assertEqual('5', result) # Test a valid command with missing param text = 'test_command' mock_slack_data = get_mock_slack_data(text=text) result = bot.dispatch(mock_slack_data) self.assertEqual(bot.no_command_found(text), result) # Test invalid command text = 'invalid' mock_slack_data = get_mock_slack_data(text=text) result = bot.dispatch(mock_slack_data) self.assertEqual(bot.no_command_found(text), result)

apache-2.0

opendroid-Team/enigma2-4.1

lib/python/Screens/Ci.py

5

11213

from Screen import Screen from Components.ActionMap import ActionMap from Components.ActionMap import NumberActionMap from Components.Label import Label from Components.config import config, ConfigSubsection, ConfigSelection, ConfigSubList, getConfigListEntry, KEY_LEFT, KEY_RIGHT, KEY_0, ConfigNothing, ConfigPIN from Components.ConfigList import ConfigList from Components.SystemInfo import SystemInfo from enigma import eTimer, eDVBCI_UI, eDVBCIInterfaces MAX_NUM_CI = 4 def setCIBitrate(configElement): if configElement.getValue() == "no": eDVBCI_UI.getInstance().setClockRate(configElement.slotid, eDVBCI_UI.rateNormal) else: eDVBCI_UI.getInstance().setClockRate(configElement.slotid, eDVBCI_UI.rateHigh) def InitCiConfig(): config.ci = ConfigSubList() for slot in range(MAX_NUM_CI): config.ci.append(ConfigSubsection()) config.ci[slot].canDescrambleMultipleServices = ConfigSelection(choices = [("auto", _("Auto")), ("no", _("No")), ("yes", _("Yes"))], default = "auto") if SystemInfo["CommonInterfaceSupportsHighBitrates"]: config.ci[slot].canHandleHighBitrates = ConfigSelection(choices = [("no", _("No")), ("yes", _("Yes"))], default = "yes") config.ci[slot].canHandleHighBitrates.slotid = slot config.ci[slot].canHandleHighBitrates.addNotifier(setCIBitrate) class MMIDialog(Screen): def __init__(self, session, slotid, action, handler = eDVBCI_UI.getInstance(), wait_text = _("wait for ci...") ): Screen.__init__(self, session) print "MMIDialog with action" + str(action) self.mmiclosed = False self.tag = None self.slotid = slotid self.timer = eTimer() self.timer.callback.append(self.keyCancel) #else the skins fails self["title"] = Label("") self["subtitle"] = Label("") self["bottom"] = Label("") self["entries"] = ConfigList([ ]) self["actions"] = NumberActionMap(["SetupActions"], { "ok": self.okbuttonClick, "cancel": self.keyCancel, #for PIN "left": self.keyLeft, "right": self.keyRight, "1": self.keyNumberGlobal, "2": self.keyNumberGlobal, "3": self.keyNumberGlobal, "4": self.keyNumberGlobal, "5": self.keyNumberGlobal, "6": self.keyNumberGlobal, "7": self.keyNumberGlobal, "8": self.keyNumberGlobal, "9": self.keyNumberGlobal, "0": self.keyNumberGlobal }, -1) self.action = action self.handler = handler self.wait_text = wait_text if action == 2: #start MMI handler.startMMI(self.slotid) self.showWait() elif action == 3: #mmi already there (called from infobar) self.showScreen() def addEntry(self, list, entry): if entry[0] == "TEXT": #handle every item (text / pin only?) list.append( (entry[1], ConfigNothing(), entry[2]) ) if entry[0] == "PIN": pinlength = entry[1] if entry[3] == 1: # masked pins: x = ConfigPIN(0, len = pinlength, censor = "*") else: # unmasked pins: x = ConfigPIN(0, len = pinlength) x.addEndNotifier(self.pinEntered) self["subtitle"].setText(entry[2]) list.append( getConfigListEntry("", x) ) self["bottom"].setText(_("please press OK when ready")) def pinEntered(self, value): self.okbuttonClick() def okbuttonClick(self): self.timer.stop() if not self.tag: return if self.tag == "WAIT": print "do nothing - wait" elif self.tag == "MENU": print "answer MENU" cur = self["entries"].getCurrent() if cur: self.handler.answerMenu(self.slotid, cur[2]) else: self.handler.answerMenu(self.slotid, 0) self.showWait() elif self.tag == "LIST": print "answer LIST" self.handler.answerMenu(self.slotid, 0) self.showWait() elif self.tag == "ENQ": cur = self["entries"].getCurrent() answer = str(cur[1].getValue()) length = len(answer) while length < cur[1].getLength(): answer = '0'+answer length+=1 self.handler.answerEnq(self.slotid, answer) self.showWait() def closeMmi(self): self.timer.stop() self.close(self.slotid) def keyCancel(self): self.timer.stop() if not self.tag or self.mmiclosed: self.closeMmi() elif self.tag == "WAIT": self.handler.stopMMI(self.slotid) self.closeMmi() elif self.tag in ( "MENU", "LIST" ): print "cancel list" self.handler.answerMenu(self.slotid, 0) self.showWait() elif self.tag == "ENQ": print "cancel enq" self.handler.cancelEnq(self.slotid) self.showWait() else: print "give cancel action to ci" def keyConfigEntry(self, key): self.timer.stop() try: self["entries"].handleKey(key) except: pass def keyNumberGlobal(self, number): self.timer.stop() self.keyConfigEntry(KEY_0 + number) def keyLeft(self): self.timer.stop() self.keyConfigEntry(KEY_LEFT) def keyRight(self): self.timer.stop() self.keyConfigEntry(KEY_RIGHT) def updateList(self, list): List = self["entries"] try: List.instance.moveSelectionTo(0) except: pass List.l.setList(list) def showWait(self): self.tag = "WAIT" self["title"].setText("") self["subtitle"].setText("") self["bottom"].setText("") list = [(self.wait_text, ConfigNothing())] self.updateList(list) def showScreen(self): screen = self.handler.getMMIScreen(self.slotid) list = [ ] self.timer.stop() if len(screen) > 0 and screen[0][0] == "CLOSE": timeout = screen[0][1] self.mmiclosed = True if timeout > 0: self.timer.start(timeout*1000, True) else: self.keyCancel() else: self.mmiclosed = False self.tag = screen[0][0] for entry in screen: if entry[0] == "PIN": self.addEntry(list, entry) else: if entry[0] == "TITLE": self["title"].setText(entry[1]) elif entry[0] == "SUBTITLE": self["subtitle"].setText(entry[1]) elif entry[0] == "BOTTOM": self["bottom"].setText(entry[1]) elif entry[0] == "TEXT": self.addEntry(list, entry) self.updateList(list) def ciStateChanged(self): do_close = False if self.action == 0: #reset do_close = True if self.action == 1: #init do_close = True #module still there ? if self.handler.getState(self.slotid) != 2: do_close = True #mmi session still active ? if self.handler.getMMIState(self.slotid) != 1: do_close = True if do_close: self.closeMmi() elif self.action > 1 and self.handler.availableMMI(self.slotid) == 1: self.showScreen() #FIXME: check for mmi-session closed class CiMessageHandler: def __init__(self): self.session = None self.ci = { } self.dlgs = { } eDVBCI_UI.getInstance().ciStateChanged.get().append(self.ciStateChanged) SystemInfo["CommonInterface"] = eDVBCIInterfaces.getInstance().getNumOfSlots() > 0 try: file = open("/proc/stb/tsmux/ci0_tsclk", "r") file.close() SystemInfo["CommonInterfaceSupportsHighBitrates"] = True except: SystemInfo["CommonInterfaceSupportsHighBitrates"] = False def setSession(self, session): self.session = session def ciStateChanged(self, slot): if slot in self.ci: self.ci[slot](slot) else: if slot in self.dlgs: self.dlgs[slot].ciStateChanged() elif eDVBCI_UI.getInstance().availableMMI(slot) == 1: if self.session and not config.usage.hide_ci_messages.getValue(): self.dlgs[slot] = self.session.openWithCallback(self.dlgClosed, MMIDialog, slot, 3) def dlgClosed(self, slot): if slot in self.dlgs: del self.dlgs[slot] def registerCIMessageHandler(self, slot, func): self.unregisterCIMessageHandler(slot) self.ci[slot] = func def unregisterCIMessageHandler(self, slot): if slot in self.ci: del self.ci[slot] CiHandler = CiMessageHandler() class CiSelection(Screen): def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("Common Interface")) self["actions"] = ActionMap(["OkCancelActions", "CiSelectionActions"], { "left": self.keyLeft, "right": self.keyLeft, "ok": self.okbuttonClick, "cancel": self.cancel },-1) self.dlg = None self.state = { } self.list = [ ] for slot in range(MAX_NUM_CI): state = eDVBCI_UI.getInstance().getState(slot) if state != -1: self.appendEntries(slot, state) CiHandler.registerCIMessageHandler(slot, self.ciStateChanged) menuList = ConfigList(self.list) menuList.list = self.list menuList.l.setList(self.list) self["entries"] = menuList self["entries"].onSelectionChanged.append(self.selectionChanged) self["text"] = Label(_("Slot %d")% 1) def selectionChanged(self): cur_idx = self["entries"].getCurrentIndex() self["text"].setText(_("Slot %d")%((cur_idx / 5)+1)) def keyConfigEntry(self, key): try: self["entries"].handleKey(key) self["entries"].getCurrent()[1].save() except: pass def keyLeft(self): self.keyConfigEntry(KEY_LEFT) def keyRight(self): self.keyConfigEntry(KEY_RIGHT) def appendEntries(self, slot, state): self.state[slot] = state self.list.append( (_("Reset"), ConfigNothing(), 0, slot) ) self.list.append( (_("Init"), ConfigNothing(), 1, slot) ) if self.state[slot] == 0: #no module self.list.append( (_("no module found"), ConfigNothing(), 2, slot) ) elif self.state[slot] == 1: #module in init self.list.append( (_("init module"), ConfigNothing(), 2, slot) ) elif self.state[slot] == 2: #module ready #get appname appname = eDVBCI_UI.getInstance().getAppName(slot) self.list.append( (appname, ConfigNothing(), 2, slot) ) self.list.append(getConfigListEntry(_("Multiple service support"), config.ci[slot].canDescrambleMultipleServices)) if SystemInfo["CommonInterfaceSupportsHighBitrates"]: self.list.append(getConfigListEntry(_("High bitrate support"), config.ci[slot].canHandleHighBitrates)) def updateState(self, slot): state = eDVBCI_UI.getInstance().getState(slot) self.state[slot] = state slotidx=0 while len(self.list[slotidx]) < 3 or self.list[slotidx][3] != slot: slotidx += 1 slotidx += 1 # do not change Reset slotidx += 1 # do not change Init if state == 0: #no module self.list[slotidx] = (_("no module found"), ConfigNothing(), 2, slot) elif state == 1: #module in init self.list[slotidx] = (_("init module"), ConfigNothing(), 2, slot) elif state == 2: #module ready #get appname appname = eDVBCI_UI.getInstance().getAppName(slot) self.list[slotidx] = (appname, ConfigNothing(), 2, slot) lst = self["entries"] lst.list = self.list lst.l.setList(self.list) def ciStateChanged(self, slot): if self.dlg: self.dlg.ciStateChanged() else: state = eDVBCI_UI.getInstance().getState(slot) if self.state[slot] != state: #print "something happens" self.state[slot] = state self.updateState(slot) def dlgClosed(self, slot): self.dlg = None def okbuttonClick(self): cur = self["entries"].getCurrent() if cur and len(cur) > 2: action = cur[2] slot = cur[3] if action == 0: #reset eDVBCI_UI.getInstance().setReset(slot) elif action == 1: #init eDVBCI_UI.getInstance().setInit(slot) elif self.state[slot] == 2: self.dlg = self.session.openWithCallback(self.dlgClosed, MMIDialog, slot, action) def cancel(self): for slot in range(MAX_NUM_CI): state = eDVBCI_UI.getInstance().getState(slot) if state != -1: CiHandler.unregisterCIMessageHandler(slot) self.close()

gpl-2.0

VUIIS/seam

setup.py

1

3188

#!/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'Scott Burns <scott.s.burns@vanderbilt.edu>' __copyright__ = 'Copyright 2014 Vanderbilt University. All Rights Reserved' from setuptools import setup, find_packages import os import re from io import open import codecs here = os.path.abspath(os.path.dirname(__file__)) # Read the version number from a source file. # Code taken from pip's setup.py def find_version(*file_paths): # Open in Latin-1 so that we avoid encoding errors. # Use codecs.open for Python 2 compatibility with codecs.open(os.path.join(here, *file_paths), 'r', 'latin1') as f: version_file = f.read() # The version line must have the form # __version__ = 'ver' version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M) if version_match: return version_match.group(1) raise RuntimeError("Unable to find version string.") # Get the long description from the relevant file with open('README.md', encoding='utf-8') as f: long_description = f.read() setup( name="seam", version=find_version('seam', '__init__.py'), description="A simple layer between neuroimaging tools and your data", long_description=long_description, # The project URL. url='http://github.com/VUIIS/seam', # Author details author='Scott Burns', author_email='scott.s.burns@vanderbilt.edu', # Choose your license license='MIT', classifiers=[ 'Development Status :: 1 - Planning', # 'Development Status :: 2 - Pre-Alpha', # 'Development Status :: 3 - Alpha', # 'Development Status :: 4 - Beta', # 'Development Status :: 5 - Production/Stable', # 'Development Status :: 6 - Mature', # Indicate who your project is intended for 'Intended Audience :: Science/Research', 'Topic :: Scientific/Engineering', 'Topic :: Scientific/Engineering :: Bio-Informatics', # Pick your license as you wish (should match "license" above) 'License :: OSI Approved :: MIT License', # Specify the Python versions you support here. In particular, ensure # that you indicate whether you support Python 2, Python 3 or both. 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.3', ], # What does your project relate to? keywords='neuroimaging data analysis', # You can just specify the packages manually here if your project is # simple. Or you can use find_packages. packages=find_packages(exclude=["contrib", "docs", "tests*"]), # If there are data files included in your packages, specify them here. package_data={ }, # To provide executable scripts, use entry points in preference to the # "scripts" keyword. Entry points provide cross-platform support and allow # pip to create the appropriate form of executable for the target platform. entry_points={'console_scripts': [ 'build-recon-v1 = seam.freesurfer.v1.recipe:main'] }, )

mit

davvid/qtpy

qtpy/tests/test_patch_qheaderview.py

1

3524

from __future__ import absolute_import from qtpy import PYSIDE, PYQT4 from qtpy.QtWidgets import QApplication from qtpy.QtWidgets import QHeaderView from qtpy.QtCore import Qt from qtpy.QtCore import QAbstractListModel import pytest def get_qapp(icon_path=None): qapp = QApplication.instance() if qapp is None: qapp = QApplication(['']) return qapp def test_patched_qheaderview(): """ This will test whether QHeaderView has the new methods introduced in Qt5. It will then create an instance of QHeaderView and test that no exceptions are raised and that some basic behaviour works. """ assert QHeaderView.sectionsClickable is not None assert QHeaderView.sectionsMovable is not None assert QHeaderView.sectionResizeMode is not None assert QHeaderView.setSectionsClickable is not None assert QHeaderView.setSectionsMovable is not None assert QHeaderView.setSectionResizeMode is not None # setup a model and add it to a headerview qapp = get_qapp() headerview = QHeaderView(Qt.Horizontal) class Model(QAbstractListModel): pass model = Model() headerview.setModel(model) assert headerview.count() == 1 # test it assert isinstance(headerview.sectionsClickable(), bool) assert isinstance(headerview.sectionsMovable(), bool) if PYSIDE: assert isinstance(headerview.sectionResizeMode(0), QHeaderView.ResizeMode) else: assert isinstance(headerview.sectionResizeMode(0), int) headerview.setSectionsClickable(True) assert headerview.sectionsClickable() == True headerview.setSectionsClickable(False) assert headerview.sectionsClickable() == False headerview.setSectionsMovable(True) assert headerview.sectionsMovable() == True headerview.setSectionsMovable(False) assert headerview.sectionsMovable() == False headerview.setSectionResizeMode(QHeaderView.Interactive) assert headerview.sectionResizeMode(0) == QHeaderView.Interactive headerview.setSectionResizeMode(QHeaderView.Fixed) assert headerview.sectionResizeMode(0) == QHeaderView.Fixed headerview.setSectionResizeMode(QHeaderView.Stretch) assert headerview.sectionResizeMode(0) == QHeaderView.Stretch headerview.setSectionResizeMode(QHeaderView.ResizeToContents) assert headerview.sectionResizeMode(0) == QHeaderView.ResizeToContents headerview.setSectionResizeMode(0, QHeaderView.Interactive) assert headerview.sectionResizeMode(0) == QHeaderView.Interactive headerview.setSectionResizeMode(0, QHeaderView.Fixed) assert headerview.sectionResizeMode(0) == QHeaderView.Fixed headerview.setSectionResizeMode(0, QHeaderView.Stretch) assert headerview.sectionResizeMode(0) == QHeaderView.Stretch headerview.setSectionResizeMode(0, QHeaderView.ResizeToContents) assert headerview.sectionResizeMode(0) == QHeaderView.ResizeToContents # test that the old methods in Qt4 raise exceptions if PYQT4 or PYSIDE: with pytest.raises(Exception): headerview.isClickable() with pytest.raises(Exception): headerview.isMovable() with pytest.raises(Exception): headerview.resizeMode(0) with pytest.raises(Exception): headerview.setClickable(True) with pytest.raises(Exception): headerview.setMovableClickable(True) with pytest.raises(Exception): headerview.setResizeMode(0, QHeaderView.Interactive)

mit

Rositsazz/hack33

config/urls.py

2

1599

# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.conf import settings from django.conf.urls import include, url from django.conf.urls.static import static from django.contrib import admin from django.views.generic import TemplateView from django.views import defaults as default_views urlpatterns = [ url(r'^$', TemplateView.as_view(template_name='pages/home.html'), name='home'), url(r'^about/$', TemplateView.as_view(template_name='pages/about.html'), name='about'), # Django Admin, use {% url 'admin:index' %} url(settings.ADMIN_URL, admin.site.urls), # User management url(r'^users/', include('hack33.users.urls', namespace='users')), url(r'^accounts/', include('allauth.urls')), # Your stuff: custom urls includes go here ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) if settings.DEBUG: # This allows the error pages to be debugged during development, just visit # these url in browser to see how these error pages look like. urlpatterns += [ url(r'^400/$', default_views.bad_request, kwargs={'exception': Exception('Bad Request!')}), url(r'^403/$', default_views.permission_denied, kwargs={'exception': Exception('Permission Denied')}), url(r'^404/$', default_views.page_not_found, kwargs={'exception': Exception('Page not Found')}), url(r'^500/$', default_views.server_error), ] if 'debug_toolbar' in settings.INSTALLED_APPS: import debug_toolbar urlpatterns += [ url(r'^__debug__/', include(debug_toolbar.urls)), ]

mit

heenbo/mosquitto-heenbo

test/lib/03-publish-c2b-qos1-disconnect.py

7

2303

#!/usr/bin/env python # Test whether a client sends a correct PUBLISH to a topic with QoS 1, then responds correctly to a disconnect. import inspect import os import subprocess import socket import sys import time # From http://stackoverflow.com/questions/279237/python-import-a-module-from-a-folder cmd_subfolder = os.path.realpath(os.path.abspath(os.path.join(os.path.split(inspect.getfile( inspect.currentframe() ))[0],".."))) if cmd_subfolder not in sys.path: sys.path.insert(0, cmd_subfolder) import mosq_test rc = 1 keepalive = 60 connect_packet = mosq_test.gen_connect("publish-qos1-test", keepalive=keepalive) connack_packet = mosq_test.gen_connack(rc=0) disconnect_packet = mosq_test.gen_disconnect() mid = 1 publish_packet = mosq_test.gen_publish("pub/qos1/test", qos=1, mid=mid, payload="message") publish_packet_dup = mosq_test.gen_publish("pub/qos1/test", qos=1, mid=mid, payload="message", dup=True) puback_packet = mosq_test.gen_puback(mid) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.settimeout(10) sock.bind(('', 1888)) sock.listen(5) client_args = sys.argv[1:] env = dict(os.environ) env['LD_LIBRARY_PATH'] = '../../lib:../../lib/cpp' try: pp = env['PYTHONPATH'] except KeyError: pp = '' env['PYTHONPATH'] = '../../lib/python:'+pp client = mosq_test.start_client(filename=sys.argv[1].replace('/', '-'), cmd=client_args, env=env) try: (conn, address) = sock.accept() conn.settimeout(15) if mosq_test.expect_packet(conn, "connect", connect_packet): conn.send(connack_packet) if mosq_test.expect_packet(conn, "publish", publish_packet): # Disconnect client. It should reconnect. conn.close() (conn, address) = sock.accept() conn.settimeout(15) if mosq_test.expect_packet(conn, "connect", connect_packet): conn.send(connack_packet) if mosq_test.expect_packet(conn, "retried publish", publish_packet_dup): conn.send(puback_packet) if mosq_test.expect_packet(conn, "disconnect", disconnect_packet): rc = 0 conn.close() finally: client.terminate() client.wait() sock.close() exit(rc)

gpl-3.0

lmazuel/azure-sdk-for-python

azure-mgmt-network/azure/mgmt/network/v2017_09_01/models/connectivity_issue_py3.py

1

2129

# 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 msrest.serialization import Model class ConnectivityIssue(Model): """Information about an issue encountered in the process of checking for connectivity. Variables are only populated by the server, and will be ignored when sending a request. :ivar origin: The origin of the issue. Possible values include: 'Local', 'Inbound', 'Outbound' :vartype origin: str or ~azure.mgmt.network.v2017_09_01.models.Origin :ivar severity: The severity of the issue. Possible values include: 'Error', 'Warning' :vartype severity: str or ~azure.mgmt.network.v2017_09_01.models.Severity :ivar type: The type of issue. Possible values include: 'Unknown', 'AgentStopped', 'GuestFirewall', 'DnsResolution', 'SocketBind', 'NetworkSecurityRule', 'UserDefinedRoute', 'PortThrottled', 'Platform' :vartype type: str or ~azure.mgmt.network.v2017_09_01.models.IssueType :ivar context: Provides additional context on the issue. :vartype context: list[dict[str, str]] """ _validation = { 'origin': {'readonly': True}, 'severity': {'readonly': True}, 'type': {'readonly': True}, 'context': {'readonly': True}, } _attribute_map = { 'origin': {'key': 'origin', 'type': 'str'}, 'severity': {'key': 'severity', 'type': 'str'}, 'type': {'key': 'type', 'type': 'str'}, 'context': {'key': 'context', 'type': '[{str}]'}, } def __init__(self, **kwargs) -> None: super(ConnectivityIssue, self).__init__(**kwargs) self.origin = None self.severity = None self.type = None self.context = None

mit

yassen-itlabs/py-linux-traffic-control

pyltc/util/cmdline.py

1

5206

""" Command line execution utility module. """ import time import subprocess def popen_factory(): """Returns subprocess.Popen on Linux, otherwise returns MockPopen class assuming this is a test run.""" import platform if platform.system() == 'Linux': return subprocess.Popen class MockPopen(object): """Mocks command execution to allow testing on non-Linux OS.""" def __init__(self, command_list, *args, **kw): self._cmd_list = command_list self._args = args self._kw = kw self.returncode = 0 def communicate(self, timeout=None): if self._cmd_list[0].endswith('echo'): return bytes(" ".join(self._cmd_list[1:]), encoding='utf-8'), None if self._cmd_list[0].endswith('/bin/true'): return None, None if self._cmd_list[0].endswith('/bin/false'): self.returncode = 1 return None, None if self._cmd_list[0].endswith('sleep'): pause = float(self._cmd_list[1]) if timeout and timeout < pause: time.sleep(timeout) cmd = " ".join(self._cmd_list) raise subprocess.TimeoutExpired(cmd, timeout) time.sleep(pause) return None, None raise RuntimeError("UNREACHABLE") return MockPopen class CommandFailed(Exception): """Rased when a command line execution yielded a non-zero return code.""" def __init__(self, command): assert isinstance(command, CommandLine) and command.returncode, \ "expecting failed command, got {!r}".format(command) output = command.stderr if command.stdout: output = "out:{}\nerr: {}".format(command.stdout, output) msg = "Command failed (rc={}, {!r})".format(command.returncode, command.cmdline) if output: msg += ": " + output super(CommandFailed, self).__init__(msg) self._command = command @property def returncode(self): return self._command.returncode class CommandLine(object): """Command line execution class.""" def __init__(self, cmdline, ignore_errors=False, verbose=False, sudo=False): self._cmdline = cmdline self._ignore_errors = ignore_errors self._verbose = verbose self._sudo = sudo self._returncode = None self._stdout = None self._stderr = None self._proc = None @property def cmdline(self): return self._cmdline def _construct_cmd_list(self, command): """Recursively process the command string to exctract any quoted segments as a single command element. """ QUOTE = '"' def validate(command): quote_count = command.count(QUOTE) if quote_count % 2 != 0: raise RuntimeError('Unbalanced quotes in command: {!r}'.format(command)) def construct_the_list(command): if QUOTE not in command: return command.split() left, mid, right = command.split(QUOTE, 2) return left.split() + [mid] + construct_the_list(right) # recursively process the right part validate(command) result = ['sudo'] if self._sudo else [] result += construct_the_list(command) return result def terminate(self): # TODO: refactor if not self._proc: return None self._proc.terminate() rc = self._proc.poll() c = 0 while rc == None: time.sleep(0.1) if c > 19: self._proc.kill() break c += 1 rc = self._proc.poll() time.sleep(0.1) return self._proc.poll() def execute_daemon(self): command_list = self._construct_cmd_list(self._cmdline) PopenClass = popen_factory() proc = PopenClass(command_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE) self._proc = proc return self # allows for one-line creation + execution with assignment def execute(self, timeout=10): """Prepares and executes the command.""" command_list = self._construct_cmd_list(self._cmdline) PopenClass = popen_factory() proc = PopenClass(command_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE) self._proc = proc stdout, stderr = proc.communicate(timeout=timeout) self._stdout = stdout.decode('unicode_escape') if stdout else "" self._stderr = stderr.decode('unicode_escape') if stderr else "" rc = proc.returncode self._returncode = rc if self._verbose: print(">", " ".join(command_list)) if rc and not self._ignore_errors: raise CommandFailed(self) return self # allows for one-line creation + execution with assignment @property def returncode(self): return self._returncode @property def stdout(self): return self._stdout @property def stderr(self): return self._stderr

mit

chemelnucfin/tensorflow

tensorflow/python/keras/mixed_precision/experimental/__init__.py

8

1179

# Copyright 2019 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. # ============================================================================== """Mixed precision API.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function from tensorflow.python.keras.mixed_precision.experimental.loss_scale_optimizer import LossScaleOptimizer from tensorflow.python.keras.mixed_precision.experimental.policy import global_policy from tensorflow.python.keras.mixed_precision.experimental.policy import Policy from tensorflow.python.keras.mixed_precision.experimental.policy import set_policy

apache-2.0

xiaokangwang/KKWebVideoDL-X

youtube_dl/extractor/wimp.py

6

1302

import re import base64 from .common import InfoExtractor class WimpIE(InfoExtractor): _VALID_URL = r'(?:http://)?(?:www\.)?wimp\.com/([^/]+)/' _TEST = { u'url': u'http://www.wimp.com/deerfence/', u'file': u'deerfence.flv', u'md5': u'8b215e2e0168c6081a1cf84b2846a2b5', u'info_dict': { u"title": u"Watch Till End: Herd of deer jump over a fence." } } def _real_extract(self, url): mobj = re.match(self._VALID_URL, url) video_id = mobj.group(1) webpage = self._download_webpage(url, video_id) title = self._search_regex(r'<meta name="description" content="(.+?)" />',webpage, 'video title') thumbnail_url = self._search_regex(r'<meta property="og\:image" content="(.+?)" />', webpage,'video thumbnail') googleString = self._search_regex("googleCode = '(.*?)'", webpage, 'file url') googleString = base64.b64decode(googleString).decode('ascii') final_url = self._search_regex('","(.*?)"', googleString,'final video url') ext = final_url.rpartition(u'.')[2] return [{ 'id': video_id, 'url': final_url, 'ext': ext, 'title': title, 'thumbnail': thumbnail_url, }]

gpl-3.0

benthomasson/msa-designer

msa_designer/server.py

1

3482

from gevent import monkey monkey.patch_all() import os import socket import pkg_resources import logging import hashlib import yaml import json from pprint import pprint from jinja2 import Environment, PackageLoader env = Environment(loader=PackageLoader('msa_designer_web', 'templates')) from bottle import route, request from bottle import static_file from bottle import redirect from socketio.namespace import BaseNamespace from socketio.mixins import BroadcastMixin logger = logging.getLogger('msa-designer.server') saved_msas_root = os.path.abspath("saved_msas") load_msas_root = os.path.abspath("loaded_msas") if not os.path.exists(saved_msas_root): os.makedirs(saved_msas_root) if not os.path.exists(load_msas_root): os.makedirs(load_msas_root) class AgentNamespace(BaseNamespace, BroadcastMixin): def initialize(self): logger.debug("INIT") print self.__dict__.keys() print self.ns_name print self.request def on_save(self, message): logger.debug("save %s", message) app_name = message.get('app', 'msa') data = yaml.safe_dump(message, default_flow_style=False) save_id = hashlib.sha1(data).hexdigest() url = '/save/{0}/{1}.yml'.format(save_id, app_name) with open(os.path.join(saved_msas_root, save_id), 'w') as f: f.write(data) self.emit('saved', dict(url=url)) from socketio import socketio_manage @route('/status') def status(): return "running" @route('/upload', method='POST') def do_upload(): upload = request.files.get('upload') data = upload.file.read() print upload.filename, data load_id = hashlib.sha1(data).hexdigest() with open(os.path.join(load_msas_root, load_id), 'w') as f: f.write(data) return redirect("/msa/{0}".format(load_id)) @route('/socket.io/<namespace:path>') def index(namespace): socketio_manage(request.environ, {'/msa-designer': AgentNamespace}) @route('/save/<save_id:path>/<name:path>') def save(save_id, name): logger.debug("save_id %s", save_id) return static_file(save_id, root=saved_msas_root, mimetype="text/yaml", download=name) @route('/') def root(): return env.get_template('index.html').render() @route('/msa/<load_id:path>') def root(load_id): with open(os.path.join(load_msas_root, load_id)) as f: msa = json.dumps(yaml.load(f.read())) print msa return env.get_template('index.html').render(msa_to_load=msa) @route('/static/<filename:path>') def serve_static(filename): return static_file(filename, root=pkg_resources.resource_filename('msa_designer_web', 'static')) from bottle import ServerAdapter class SocketIOServer(ServerAdapter): def run(self, handler): from socketio.server import SocketIOServer resource = self.options.get('resource', 'socket.io') policy_server = self.options.get('policy_server', False) done = False while not done: try: SocketIOServer((self.host, self.port), handler, resource=resource, policy_server=policy_server, transports=['websocket', 'xhr-multipart', 'xhr-polling']).serve_forever() except socket.error, e: if e.errno == 98: logger.warning(str(e)) raise else: raise

bsd-3-clause

hudora/huTools

huTools/world.py

1

2969

#!/usr/bin/env python # encoding: utf-8 """ hutools/world - countries of the world (to be procise: countries we do buiseness with) Most interesting are the constants COUNTRY_CHOICES and COUNTRIES. COUNTRY_CHOICES = [('DE', 'Deutschland'), ('AT', u'Österreich'), ...] COUNTRIES = ['DE', 'AT', ...] Created by Maximillian Dornseif on 2007-05-01. Copyright (c) 2007, 2010 HUDORA GmbH. BSD Licensed. """ import doctest import sys COUNTRY_CHOICES = [('DE', u'Deutschland'), ('AR', u'Argentinien'), ('AT', u'Österreich'), ('AU', u'Australien'), ('BE', u'Belgien'), ('BG', u'Bulgarien'), ('CH', u'Schweiz'), ('CY', u'Zypern'), ('CZ', u'Tschechien'), ('DK', u'Dänemark'), ('EE', u'Estland'), ('ES', u'Spanien'), ('FI', u'Finnland'), ('FR', u'Frankreich'), ('GB', u'Grossbritannien'), ('GR', u'Griechenland'), ('HR', u'Kroatien'), ('HU', u'Ungarn'), ('IE', u'Irland'), ('IL', u'Israel'), ('IT', u'Italien'), ('LI', u'Liechtenstein'), ('LT', u'Litauen'), ('LU', u'Luxemburg'), ('LV', u'Lettland'), ('MT', u'Malta'), ('NL', u'Niederlande'), ('NO', u'Norwegen'), ('PL', u'Polen'), ('PT', u'Portugal'), ('RO', u'Rumänien'), ('RS', u'Republik Serbien'), ('RU', u'Russland'), ('SE', u'Schweden'), ('SG', u'Singapur'), ('SI', u'Slowenien'), ('SK', u'Slowakei'), ('US', u'USA'), ('ZA', u'Südafrika'), ] COUNTRIES = dict(COUNTRY_CHOICES).keys() # Stand: Juli 2013 - diese MÜSSEN auch in COUNTRY_CHOICES vorkommen. EUROPEAN_UNION = ['BE', 'IT', 'RO', 'BG', 'LV', 'SE', 'DK', 'LT', 'SK', 'DE', 'LU', 'SI', 'EE', 'MT', 'ES', 'FI', 'NL', 'CZ', 'FR', 'AT', 'HU', 'GR', 'PL', 'GB', 'IE', 'PT', 'CY', 'HR'] def in_european_union(isoland): """ Gibt zurück, ob ein Land Mitglied der EU ist. >>> in_european_union('DE') True >>> in_european_union('CH') False >>> all(map(in_european_union, EUROPEAN_UNION)) True >>> non_eu_countries = set((abrev for abrev, name in COUNTRY_CHOICES)) - set(EUROPEAN_UNION) >>> any(map(in_european_union, non_eu_countries)) False """ return isoland.upper() in EUROPEAN_UNION if __name__ == "__main__": failure_count, test_count = doctest.testmod() sys.exit(failure_count)

bsd-3-clause

dstanek/keystone

keystone/tests/unit/test_v3_controller.py

4

1890

# Copyright 2014 CERN. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import uuid import six from six.moves import range from testtools import matchers from keystone.common import controller from keystone import exception from keystone.tests import unit as tests class V3ControllerTestCase(tests.TestCase): """Tests for the V3Controller class.""" def setUp(self): super(V3ControllerTestCase, self).setUp() class ControllerUnderTest(controller.V3Controller): _mutable_parameters = frozenset(['hello', 'world']) self.api = ControllerUnderTest() def test_check_immutable_params(self): """Pass valid parameters to the method and expect no failure.""" ref = { 'hello': uuid.uuid4().hex, 'world': uuid.uuid4().hex } self.api.check_immutable_params(ref) def test_check_immutable_params_fail(self): """Pass invalid parameter to the method and expect failure.""" ref = {uuid.uuid4().hex: uuid.uuid4().hex for _ in range(3)} ex = self.assertRaises(exception.ImmutableAttributeError, self.api.check_immutable_params, ref) ex_msg = six.text_type(ex) self.assertThat(ex_msg, matchers.Contains(self.api.__class__.__name__)) for key in ref.keys(): self.assertThat(ex_msg, matchers.Contains(key))

apache-2.0

JohnDoee/autotorrent

autotorrent/at.py

1

22932

from __future__ import division, unicode_literals import os import hashlib import logging import platform from collections import defaultdict from .bencode import bencode, bdecode from .humanize import humanize_bytes from .utils import is_unsplitable, get_root_of_unsplitable, Pieces logger = logging.getLogger('autotorrent') class Color: BLACK = '\033[90m' RED = '\033[91m' GREEN = '\033[92m' YELLOW = '\033[93m' BLUE = '\033[94m' PINK = '\033[95m' CYAN = '\033[96m' WHITE = '\033[97m' ENDC = '\033[0m' COLOR_OK = Color.GREEN COLOR_MISSING_FILES = Color.RED COLOR_ALREADY_SEEDING = Color.BLUE COLOR_FOLDER_EXIST_NOT_SEEDING = Color.YELLOW COLOR_FAILED_TO_ADD_TO_CLIENT = Color.PINK class Status: OK = 0 MISSING_FILES = 1 ALREADY_SEEDING = 2 FOLDER_EXIST_NOT_SEEDING = 3 FAILED_TO_ADD_TO_CLIENT = 4 status_messages = { Status.OK: '%sOK%s' % (COLOR_OK, Color.ENDC), Status.MISSING_FILES: '%sMissing%s' % (COLOR_MISSING_FILES, Color.ENDC), Status.ALREADY_SEEDING: '%sSeeded%s' % (COLOR_ALREADY_SEEDING, Color.ENDC), Status.FOLDER_EXIST_NOT_SEEDING: '%sExists%s' % (COLOR_FOLDER_EXIST_NOT_SEEDING, Color.ENDC), Status.FAILED_TO_ADD_TO_CLIENT: '%sFailed%s' % (COLOR_FAILED_TO_ADD_TO_CLIENT, Color.ENDC), } CHUNK_SIZE = 65536 class UnknownLinkTypeException(Exception): pass class IllegalPathException(Exception): pass class AutoTorrent(object): def __init__(self, db, client, store_path, add_limit_size, add_limit_percent, delete_torrents, link_type='soft'): self.db = db self.client = client self.store_path = store_path self.add_limit_size = add_limit_size self.add_limit_percent = add_limit_percent self.delete_torrents = delete_torrents self.link_type = link_type self.torrents_seeded = set() def try_decode(self, value): try: return value.decode('utf-8') except UnicodeDecodeError: logger.debug('Failed to decode %r using UTF-8' % value) return value.decode('iso-8859-1') def is_legal_path(self, path): for p in path: if p in ['.', '..'] or '/' in p: return False return True def populate_torrents_seeded(self): """ Fetches a list of currently-seeded info hashes """ self.torrents_seeded = set(x.lower() for x in self.client.get_torrents()) def get_info_hash(self, torrent): """ Creates the info hash of a torrent """ return hashlib.sha1(bencode(torrent[b'info'])).hexdigest() def find_hash_checks(self, torrent, result): """ Uses hash checking to find pieces """ modified_result = False pieces = Pieces(torrent) if self.db.hash_slow_mode: logger.info('Slow mode enabled, building hash size table') self.db.build_hash_size_table() start_size = 0 end_size = 0 logger.info('Hash scan mode enabled, checking for incomplete files') for f in result: start_size = end_size end_size += f['length'] if f['completed']: continue files_to_check = [] logger.debug('Building list of file names to match hash with.') if self.db.hash_size_mode: logger.debug('Using hash size mode to find files') files_to_check += self.db.find_hash_size(f['length']) if self.db.hash_name_mode: logger.debug('Using hash name mode to find files') name = f['path'][-1] files_to_check += self.db.find_hash_name(name) if self.db.hash_slow_mode: logger.debug('Using hash slow mode to find files') files_to_check += self.db.find_hash_varying_size(f['length']) logger.debug('Found %i files to check for matching hash' % len(files_to_check)) checked_files = set() for db_file in files_to_check: if db_file in checked_files: logger.debug('File %s already checked, skipping' % db_file) checked_files.add(db_file) logger.info('Hash checking %s' % db_file) match_start, match_end = pieces.match_file(db_file, start_size, end_size) logger.info('We go result for file %s start:%s end:%s' % (db_file, match_start, match_end)) if match_start or match_end: # this file is all-good size = os.path.getsize(db_file) if size != f['length']: # size does not match, need to align file logger.debug('File does not have correct size, need to align it') if match_start and match_end: logger.debug('Need to find alignment in the middle of the file') modification_point = pieces.find_piece_breakpoint(db_file, start_size, end_size) elif match_start: logger.debug('Need to modify from the end of the file') modification_point = min(f['length'], size) elif match_end: logger.debug('Need to modify at the front of the file') modification_point = 0 if size > f['length']: modification_action = 'remove' else: modification_action = 'add' f['completed'] = False f['postprocessing'] = ('rewrite', modification_action, modification_point) modified_result = True else: logger.debug('Perfect size, perfect match !') f['completed'] = True f['actual_path'] = db_file break return modified_result, result def index_torrent(self, torrent): """ Indexes the files in the torrent. """ torrent_name = torrent[b'info'][b'name'] logger.debug('Handling torrent name %r' % (torrent_name, )) torrent_name = self.try_decode(torrent_name) if not self.is_legal_path([torrent_name]): raise IllegalPathException('That is a dangerous torrent name %r, bailing' % torrent_name) logger.info('Found name %r for torrent' % torrent_name) if self.db.exact_mode: prefix = 'd' if b'files' in torrent[b'info'] else 'f' paths = self.db.find_exact_file_path(prefix, torrent_name) if paths: for path in paths: logger.debug('Checking exact path %r' % path) if prefix == 'f': logger.info('Did an exact match to a file') size = os.path.getsize(path) if torrent[b'info'][b'length'] != size: continue return {'mode': 'exact', 'source_path': os.path.dirname(path), 'files': [{ 'actual_path': path, 'length': size, 'path': [torrent_name], 'completed': True, }]} else: result = [] for f in torrent[b'info'][b'files']: orig_path = [self.try_decode(x) for x in f[b'path']] p = os.path.join(path, *orig_path) if not os.path.isfile(p): logger.debug('File %r does not exist' % p) break size = os.path.getsize(p) if size != f[b'length']: logger.debug('File %r did not match, this is not exact (got size %s, expected %s)' % (p, size, f[b'length'])) break result.append({ 'actual_path': p, 'length': f[b'length'], 'path': orig_path, 'completed': True, }) else: logger.info('Did an exact match to a path') return {'mode': 'exact', 'source_path': path, 'files': result} result = [] if b'files' in torrent[b'info']: # multifile torrent files_sorted = {} files = {} if b'files' in torrent[b'info']: i = 0 path_files = defaultdict(list) for f in torrent[b'info'][b'files']: logger.debug('Handling torrent file %r' % (f, )) orig_path = [self.try_decode(x) for x in f[b'path'] if x] # remove empty fragments if not self.is_legal_path(orig_path): raise IllegalPathException('That is a dangerous torrent path %r, bailing' % orig_path) path = [torrent_name] + orig_path name = path.pop() path_files[os.path.join(*path)].append({ 'path': orig_path, 'length': f[b'length'], }) files_sorted['/'.join(orig_path)] = i i += 1 if self.db.unsplitable_mode: unsplitable_paths = set() for path, files in path_files.items(): if is_unsplitable(f['path'][-1] for f in files): path = path.split(os.sep) name = get_root_of_unsplitable(path) if not name: continue while path[-1] != name: path.pop() unsplitable_paths.add(os.path.join(*path)) for path, files in path_files.items(): if self.db.unsplitable_mode: path = path.split(os.sep) while path and os.path.join(*path) not in unsplitable_paths: path.pop() else: path = None if path: name = path[-1] for f in files: actual_path = self.db.find_unsplitable_file_path(name, f['path'], f['length']) f['actual_path'] = actual_path f['completed'] = actual_path is not None result += files else: for f in files: actual_path = self.db.find_file_path(f['path'][-1], f['length']) f['actual_path'] = actual_path f['completed'] = actual_path is not None result += files # re-sort the torrent to fit original ordering result = sorted(result, key=lambda x:files_sorted['/'.join(x['path'])]) else: # singlefile torrent length = torrent[b'info'][b'length'] actual_path = self.db.find_file_path(torrent_name, length) result.append({ 'actual_path': actual_path, 'length': length, 'path': [torrent_name], 'completed': actual_path is not None, }) mode = 'link' if self.db.hash_mode: modified_result, result = self.find_hash_checks(torrent, result) if modified_result: mode = 'hash' return {'mode': mode, 'files': result} def parse_torrent(self, torrent): """ Parses the torrent and finds the physical location of files in the torrent """ files = self.index_torrent(torrent) found_size, missing_size = 0, 0 for f in files['files']: if f['completed'] or f.get('postprocessing'): found_size += f['length'] else: missing_size += f['length'] return found_size, missing_size, files def link_files(self, destination_path, files): """ Links the files to the destination_path if they are found. """ if not os.path.isdir(destination_path): os.makedirs(destination_path) for f in files: if f['completed']: destination = os.path.join(destination_path, *f['path']) file_path = os.path.dirname(destination) if not os.path.isdir(file_path): logger.debug('Folder %r does not exist, creating' % file_path) os.makedirs(file_path) logger.debug('Making %s link from %r to %r' % (self.link_type, f['actual_path'], destination)) if self.link_type == 'soft': os.symlink(f['actual_path'], destination) elif self.link_type == 'hard': os.link(f['actual_path'], destination) elif self.link_type == 'ref': self.reflink(f['actual_path'], destination) else: raise UnknownLinkTypeException('%r is not a known link type' % self.link_type) def reflink(self, path, destination): """ Perform a reflink (if supported, currently only xfs, apfs, btrfs is) This code is modified from dvc (https://github.com/iterative/dvc/blob/f4bec650eddc8874b3f7ab2f8b34bc5dfe60fd49/dvc/system.py#L105). These libraries are available under the Apache 2.0 license, which can be obtained from http://www.apache.org/licenses/LICENSE-2.0. """ system = platform.system() logger.debug('platform is %r', system) try: if system == "Windows": ret = self.reflink_windows(path, destination) elif system == "Darwin": ret = self.reflink_darwin(path, destination) elif system == "Linux": ret = self.reflink_linux(path, destination) else: ret = -1 except IOError: ret = -1 if ret != 0: raise Exception("reflink is not supported") def reflink_linux(self, path, destination): """ Linux only reflink via syscall FICLONE on supported filesystems """ import os import fcntl FICLONE = 0x40049409 try: ret = 255 with open(path, "r") as s, open(destination, "w+") as d: ret = fcntl.ioctl(d.fileno(), FICLONE, s.fileno()) finally: if ret != 0: os.unlink(destination) return ret def reflink_windows(self, path, destination): return -1 def reflink_darwin(self, path, destination): import ctypes LIBC = "libc.dylib" LIBC_FALLBACK = "/usr/lib/libSystem.dylib" try: clib = ctypes.CDLL(LIBC) except OSError as exc: logger.debug( "unable to access '{}' (errno '{}'). " "Falling back to '{}'.".format(LIBC, exc.errno, LIBC_FALLBACK) ) if exc.errno != errno.ENOENT: raise # NOTE: trying to bypass System Integrity Protection (SIP) clib = ctypes.CDLL(LIBC_FALLBACK) if not hasattr(clib, "clonefile"): return -1 clonefile = clib.clonefile clonefile.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int] clonefile.restype = ctypes.c_int return clonefile( ctypes.c_char_p(path.encode("utf-8")), ctypes.c_char_p(destination.encode("utf-8")), ctypes.c_int(0), ) def rewrite_hashed_files(self, destination_path, files): """ Rewrites files from the actual_path to the correct file inside destination_path. """ if not os.path.isdir(destination_path): os.makedirs(destination_path) for f in files: if not f['completed'] and 'postprocessing' in f: destination = os.path.join(destination_path, *f['path']) file_path = os.path.dirname(destination) if not os.path.isdir(file_path): logger.debug('Folder %r does not exist, creating' % file_path) os.makedirs(file_path) logger.debug('Rewriting file from %r to %r' % (f['actual_path'], destination)) _, modification_action, modification_point = f['postprocessing'] current_size = os.path.getsize(f['actual_path']) expected_size = f['length'] diff = abs(current_size - expected_size) # write until modification_point, do action, write rest of file modified = False bytes_written = 0 with open(destination, 'wb') as output_fp: with open(f['actual_path'], 'rb') as input_fp: logger.debug('Opened file %s and writing its data to %s - The breakpoint is %i' % (f['actual_path'], destination, modification_point)) while True: if not modified and bytes_written == modification_point: logger.debug('Time to modify with action %s and bytes %i' % (modification_action, diff)) modified = True if modification_action == 'remove': seek_point = bytes_written + diff logger.debug('Have to shrink compared to original file, seeking to %i' % (seek_point, )) input_fp.seek(seek_point) elif modification_action == 'add': logger.debug('Need to add data, writing %i empty bytes' % diff) while diff > 0: write_bytes = min(CHUNK_SIZE, diff) output_fp.write(b'\x00' * write_bytes) diff -= write_bytes read_bytes = CHUNK_SIZE if not modified: read_bytes = min(read_bytes, modification_point-bytes_written) logger.debug('Reading %i bytes' % (read_bytes, )) data = input_fp.read(read_bytes) if not data: break output_fp.write(data) bytes_written += read_bytes logger.debug('Done rewriting file') def handle_torrentfile(self, path, dry_run=False): """ Checks a torrentfile for files to seed, groups them by found / not found. The result will also include the total size of missing / not missing files. """ logger.info('Handling file %s' % path) torrent = self.open_torrentfile(path) if self.check_torrent_in_client(torrent): self.print_status(Status.ALREADY_SEEDING, path, 'Already seeded') if self.delete_torrents: logger.info('Removing torrent %r' % path) os.remove(path) return Status.ALREADY_SEEDING found_size, missing_size, files = self.parse_torrent(torrent) if found_size + missing_size == 0: missing_percent = 100 else: missing_percent = (missing_size / (found_size + missing_size)) * 100 found_percent = 100 - missing_percent would_not_add = missing_size and missing_percent > self.add_limit_percent or missing_size > self.add_limit_size if dry_run: return found_size, missing_size, would_not_add, [f['actual_path'] for f in files['files'] if f.get('actual_path')] if would_not_add: logger.info('Files missing from %s, only %3.2f%% found (%s missing)' % (path, found_percent, humanize_bytes(missing_size))) self.print_status(Status.MISSING_FILES, path, 'Missing files, only %3.2f%% found (%s missing)' % (found_percent, humanize_bytes(missing_size))) return Status.MISSING_FILES if files['mode'] == 'link' or files['mode'] == 'hash': logger.info('Preparing torrent using link mode') destination_path = os.path.join(self.store_path, os.path.splitext(os.path.basename(path))[0]) if os.path.isdir(destination_path): logger.info('Folder exist but torrent is not seeded %s' % destination_path) self.print_status(Status.FOLDER_EXIST_NOT_SEEDING, path, 'The folder exist, but is not seeded by torrentclient') return Status.FOLDER_EXIST_NOT_SEEDING self.link_files(destination_path, files['files']) elif files['mode'] == 'exact': logger.info('Preparing torrent using exact mode') destination_path = files['source_path'] fast_resume = True if files['mode'] == 'hash': fast_resume = False logger.info('There are files found using hashing that needs rewriting.') self.rewrite_hashed_files(destination_path, files['files']) if self.delete_torrents: logger.info('Removing torrent %r' % path) os.remove(path) if self.client.add_torrent(torrent, destination_path, files['files'], fast_resume): self.print_status(Status.OK, path, 'Torrent added successfully') return Status.OK else: self.print_status(Status.FAILED_TO_ADD_TO_CLIENT, path, 'Failed to send torrent to client') return Status.FAILED_TO_ADD_TO_CLIENT def check_torrent_in_client(self, torrent): """ Checks if a torrent is currently seeded """ info_hash = self.get_info_hash(torrent) return info_hash in self.torrents_seeded def open_torrentfile(self, path): """ Opens and parses a torrent file """ with open(path, 'rb') as f: return bdecode(f.read()) def print_status(self, status, torrentfile, message): print(' %-20s %r %s' % ('[%s]' % status_messages[status], os.path.splitext(os.path.basename(torrentfile))[0], message))

mit

nrupatunga/PY-GOTURN

goturn/network/regressor.py

1

5623

# Date: Friday 02 June 2017 05:04:00 PM IST # Email: nrupatunga@whodat.com # Name: Nrupatunga # Description: Basic regressor function implemented from __future__ import print_function import os import glob import numpy as np import sys import cv2 from ..helper import config sys.path.insert(0, config.CAFFE_PATH) import caffe class regressor: """Regressor Class""" def __init__(self, deploy_proto, caffe_model, gpu_id, num_inputs, do_train, logger, solver_file=None): """TODO: to be defined""" self.num_inputs = num_inputs self.logger = logger self.caffe_model_ = caffe_model self.modified_params_ = False self.mean = [104, 117, 123] self.modified_params = False self.solver_file = None if solver_file: self.solver_file = solver_file self.setupNetwork(deploy_proto, caffe_model, gpu_id, do_train) def reshape_image_inputs(self, num_images): """TODO: Docstring for reshape_image_inputs. :returns: TODO """ net = self.net net.blobs['image'].reshape(num_images, self.channels, self.height, self.width) net.blobs['target'].reshape(num_images, self.channels, self.height, self.width) def set_images(self, images, targets): """TODO: Docstring for set_images. :returns: TODO """ num_images = len(images) self.reshape_image_inputs(num_images) self.preprocess_batch(images, targets) def preprocess(self, image): """TODO: Docstring for preprocess. :arg1: TODO :returns: TODO """ num_channels = self.channels if num_channels == 1 and image.shape[2] == 3: image_out = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) elif num_channels == 1 and image.shape[2] == 4: image_out = cv2.cvtColor(image, cv2.COLOR_BGRA2GRAY) elif num_channels == 3 and image.shape[2] == 4: image_out = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR) elif num_channels == 3 and image.shape[2] == 1: image_out = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR) else: image_out = image if image_out.shape != (self.height, self.width, self.channels): image_out = cv2.resize(image_out, (self.width, self.height), interpolation=cv2.INTER_CUBIC) image_out = np.float32(image_out) image_out -= np.array(self.mean) image_out = np.transpose(image_out, [2, 0, 1]) return image_out def preprocess_batch(self, images_batch, targets_batch): """TODO: Docstring for preprocess_batch. :arg1: TODO :returns: TODO """ net = self.net num_images = len(images_batch) for i in range(num_images): image = images_batch[i] image_out = self.preprocess(image) net.blobs['image'].data[i] = image_out target = targets_batch[i] target_out = self.preprocess(target) net.blobs['target'].data[i] = target_out def setupNetwork(self, deploy_proto, caffe_model, gpu_id, do_train): """TODO: Docstring for setupNetwork. :deploy_proto (string) : deploy prototxt file :caffe_model (string) : trained caffe model path :gpu_id (integer) : GPU id :do_train (boolean) : training phase or testing phase """ logger = self.logger caffe.set_mode_gpu() caffe.set_device(int(gpu_id)) if do_train == True: logger.info('Setting phase to train') # TODO: this part of the code needs to be changed for # training phase if self.solver_file: self.solver = caffe.SGDSolver(self.solver_file) net = self.solver.net net.copy_from(caffe_model) else: logger.error('solver file required') return self.phase = caffe.TRAIN else: logger.info('Setting phase to test') net = caffe.Net(deploy_proto, caffe_model, caffe.TEST) self.phase = caffe.TEST self.net = net self.num_inputs = net.blobs['image'].data[...].shape[0] self.channels = net.blobs['image'].data[...].shape[1] self.height = net.blobs['image'].data[...].shape[2] self.width = net.blobs['image'].data[...].shape[3] if self.num_inputs != 1: logger.error('Network should take exactly one input') if self.channels != 1 and self.channels != 3: logger.error('Network should have 1 or 3 channels') def regress(self, curr_search_region, target_region): """TODO: Docstring for regress. :returns: TODO """ return self.estimate(curr_search_region, target_region) def estimate(self, curr_search_region, target_region): """TODO: Docstring for estimate. :arg1: TODO :returns: TODO """ net = self.net # reshape the inputs net.blobs['image'].data.reshape(1, self.channels, self.height, self.width) net.blobs['target'].data.reshape(1, self.channels, self.height, self.width) net.blobs['bbox'].data.reshape(1, 4, 1, 1) curr_search_region = self.preprocess(curr_search_region) target_region = self.preprocess(target_region) net.blobs['image'].data[...] = curr_search_region net.blobs['target'].data[...] = target_region net.forward() bbox_estimate = net.blobs['fc8'].data return bbox_estimate

mit

bobev18/reflective

django2wrap/settings.py

1

5385

import os # Django settings for django2wrap project. SITE_ROOT = os.path.realpath(os.path.dirname(__file__)) # + '/' PROJECT_NAME = os.path.basename(os.path.dirname(__file__)) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) fp = os.path.join(BASE_DIR, 'local_settings.py') try: exec(open(fp,'rt',encoding='utf-8').read()) except : print('!'*32, 'Failed to import', fp) print() exit(1) # Local time zone for this installation. Choices can be found here: # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name # although not all choices may be available on all operating systems. # In a Windows environment this must be set to your system time zone. TIME_ZONE = 'Europe/Sofia' # Language code for this installation. All choices can be found here: # http://www.i18nguy.com/unicode/language-identifiers.html LANGUAGE_CODE = 'en-us' SITE_ID = 1 # If you set this to False, Django will make some optimizations so as not # to load the internationalization machinery. USE_I18N = True # If you set this to False, Django will not format dates, numbers and # calendars according to the current locale. USE_L10N = True # If you set this to False, Django will not use timezone-aware datetimes. USE_TZ = True # Absolute filesystem path to the directory that will hold user-uploaded files. # Example: "/var/www/example.com/media/" MEDIA_ROOT = '' # URL that handles the media served from MEDIA_ROOT. Make sure to use a # trailing slash. # Examples: "http://example.com/media/", "http://media.example.com/" MEDIA_URL = '' # Absolute path to the directory static files should be collected to. # Don't put anything in this directory yourself; store your static files # in apps' "static/" subdirectories and in STATICFILES_DIRS. # Example: "/var/www/example.com/static/" STATIC_ROOT = SITE_ROOT + 'static_files/' # STATIC_ROOT = os.path.join(SITE_ROOT, 'static') #SITE_ROOT + 'static/' # URL prefix for static files. # Example: "http://example.com/static/", "http://static.example.com/" STATIC_URL = '/static/' # Additional locations of static files STATICFILES_DIRS = ( os.path.join(SITE_ROOT, 'static'), # Put strings here, like "/home/html/static" or "C:/www/django/static". # Always use forward slashes, even on Windows. # Don't forget to use absolute paths, not relative paths. ) # List of finder classes that know how to find static files in # various locations. STATICFILES_FINDERS = ( 'django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder', # 'django.contrib.staticfiles.finders.DefaultStorageFinder', ) # Make this unique, and don't share it with anybody. # List of callables that know how to import templates from various sources. TEMPLATE_LOADERS = ( 'django.template.loaders.filesystem.Loader', 'django.template.loaders.app_directories.Loader', # 'django.template.loaders.eggs.Loader', ) MIDDLEWARE_CLASSES = ( 'django.middleware.common.CommonMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', # Uncomment the next line for simple clickjacking protection: # 'django.middleware.clickjacking.XFrameOptionsMiddleware', ) ROOT_URLCONF = 'django2wrap.urls' # Python dotted path to the WSGI application used by Django's runserver. WSGI_APPLICATION = 'django2wrap.wsgi.application' TEMPLATE_DIRS = ( os.path.join(SITE_ROOT, 'templates'), # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates". # Always use forward slashes, even on Windows. # Don't forget to use absolute paths, not relative paths. ) # TEMPLATE_CONTEXT_PROCESSORS = ( # 'django.core.context_processors.auth', # 'django.core.context_processors.debug', # 'django.core.context_processors.i18n', # 'django.core.context_processors.media', # 'django.core.context_processors.request', # ) INSTALLED_APPS = ( 'south', 'django.contrib.auth', 'django.contrib.admin', 'django.contrib.contenttypes', 'django.contrib.messages', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.staticfiles', 'django.contrib.humanize', 'django_extensions', 'django2wrap', ) LOGIN_REDIRECT_URL = "/" ACCOUNT_ACTIVATION_DAYS = 7 # One-week activation window; you may, of course, use a different value. # email settings were here # # A sample logging configuration. The only tangible logging # performed by this configuration is to send an email to # the site admins on every HTTP 500 error when DEBUG=False. # See http://docs.djangoproject.com/en/dev/topics/logging for # more details on how to customize your logging configuration. LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'filters': { 'require_debug_false': { '()': 'django.utils.log.RequireDebugFalse' } }, 'handlers': { 'mail_admins': { 'level': 'ERROR', 'filters': ['require_debug_false'], 'class': 'django.utils.log.AdminEmailHandler' } }, 'loggers': { 'django.request': { 'handlers': ['mail_admins'], 'level': 'ERROR', 'propagate': True, }, } }

bsd-3-clause

JackMc/CourseScraper

scraper/carleton/scrape.py

1

3008

from carleton.course import Course import requests from bs4 import BeautifulSoup import datetime import csv FALL = 0 WINTER = 1 SUMMER = 2 # Maps term codes to semesters # Experimentally determined from playing with Carleton Central. _TERM_MAP = {WINTER: '10', SUMMER: '20', FALL: '30'} def _make_term_code(year, term): # Term is invalid. if term not in _TERM_MAP: return None return str(year) + _TERM_MAP[term] def _get_session_id(): """ Returns a string used by Carleton Central to uniquely identify a session. """ get_session_id = requests.get('http://central.carleton.ca/prod/bwysched.p_select_term', params={'wsea_code': 'EXT'}) if not get_session_id.ok: # It didn't return a good response code. return None # Parse out the session ID. session_soup = BeautifulSoup(get_session_id.text) inputs = session_soup.find('input', attrs={'name': 'session_id'}) return inputs['value'] def _parse_row(row): """ Returns a two-tuple containing the parsed version of a given row. The first tuple will contain all """ if not row: return (None, None) elif 'DNI' in row: return (None, None) return ([eval(x) for x in row if x.startswith('[')], [x[1:] for x in row if x.startswith('\'')]) def get_courses(faculty, year=2014, term=FALL): """ Returns a list of Course objects for a given faculty code (i.e. COMP). """ # We grab the faculty courses page and soup it. This is a listing of courses. faculty_courses = requests.get('http://calendar.carleton.ca/undergrad/courses/' + faculty) soup = BeautifulSoup(faculty_courses.text) # This variable contains a list of the divs that contain the course info. course_divs = soup.find_all('div', attrs={'class': 'courseblock'}) courses = {} # Open up the courses/prereqs file reader = csv.reader(open(faculty + '_prereqs.csv', 'r+')) for div, row in zip(course_divs, reader): strong_block = div.find('strong') text = strong_block.text top, title = text.split('\n') # The first half of this would be the faculty code, which we already have. # Also for some reason it likes it when I split on \xa0 instead of space, # though it's visually a space. Probably a weird unicode thing. _, course_no = top.split('[')[0].strip().split('\xa0') # Another magic number... 3 is the length of both 1.0, 0.5, and 0.0 credits = float(top.split('[')[1][:3]) description = str(div.string) prereqs, text_prereqs = _parse_row(row) if prereqs is None or text_prereqs is None: continue additional = div.find('coursedescadditional') courses[faculty + course_no] = Course(credits, faculty, course_no, title, description, prereqs, text_prereqs, None, additional.get_text() if additional else None) return courses

mit

dnowatsc/Varial

varial/test/test_diskio.py

1

3008

import os from ROOT import TH1F from test_histotoolsbase import TestHistoToolsBase from varial.wrappers import FileServiceAlias from varial import diskio from varial import analysis class TestDiskio(TestHistoToolsBase): def setUp(self): super(TestDiskio, self).setUp() if not os.path.exists("test_data"): os.mkdir("test_data") def test_fileservice_aliases(self): for name, smp in analysis.all_samples.items(): analysis.fs_aliases += list( alias for alias in diskio.generate_fs_aliases( 'fileservice/%s.root' % name, smp ) ) aliases = analysis.fs_aliases[:] # Is number of loaded elements correct? self.assertEqual(len(aliases), 150) # Are sample names correct? samples = set(a.sample for a in aliases) self.assertTrue("tt" in samples) self.assertTrue("ttgamma" in samples) self.assertTrue("zjets" in samples) # Check for some analyzers analyzers = set(a.analyzer for a in aliases) self.assertTrue("realTemplate" in analyzers) self.assertTrue("analyzer_ET" in analyzers) # Check for some histonames histos = set(a.name for a in aliases) self.assertTrue("histo" in histos) self.assertTrue("sihihEB" in histos) def test_load_histogram(self): test_alias = FileServiceAlias( "cutflow", "analyzeSelection", "fileservice/ttgamma.root", analysis.all_samples["ttgamma"] ) wrp = diskio.load_histogram(test_alias) self.assertEqual(wrp.name, test_alias.name) self.assertEqual(wrp.analyzer, test_alias.analyzer) self.assertEqual(wrp.sample, test_alias.sample) self.assertTrue(isinstance(wrp.histo, TH1F)) self.assertAlmostEqual(wrp.histo.Integral(), 280555.0) def test_write(self): fname = "test_data/wrp_save.info" diskio.write(self.test_wrp, fname) # file should exist self.assertTrue( os.path.exists(fname) ) # file should have 7 lines (with history written out) with open(fname) as fhandle: n_lines = len(list(fhandle)) self.assertEqual(n_lines, 21) def test_read(self): fname = "test_data/wrp_load.info" diskio.write(self.test_wrp, fname) loaded = diskio.read(fname) self.test_wrp.history = str(self.test_wrp.history) # check names self.assertEqual( self.test_wrp.all_writeable_info(), loaded.all_writeable_info() ) # check histograms (same integral, different instance) self.assertEqual(self.test_wrp.histo.Integral(), loaded.histo.Integral()) self.assertNotEqual(str(self.test_wrp.histo), str(loaded.histo)) import unittest suite = unittest.TestLoader().loadTestsFromTestCase(TestDiskio) if __name__ == '__main__': unittest.main()

gpl-3.0

csachs/openmicroscopy

components/tools/OmeroWeb/test/integration/test_download.py

9

5019

#!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright (C) 2015 University of Dundee & Open Microscopy Environment. # All rights reserved. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # This program 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 Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. """ Test download of data. """ from omero.model import PlateI, WellI, WellSampleI from omero.rtypes import rstring import pytest from django.core.urlresolvers import reverse from weblibrary import IWebTest, _get_response class TestDownload(IWebTest): """ Tests to check download is disabled where specified. """ @pytest.fixture def image_well_plate(self): """ Returns a new OMERO Project, linked Dataset and linked Image populated by an L{test.integration.library.ITest} instance with required fields set. """ plate = PlateI() plate.name = rstring(self.uuid()) plate = self.update.saveAndReturnObject(plate) well = WellI() well.plate = plate well = self.update.saveAndReturnObject(well) image = self.new_image(name=self.uuid()) ws = WellSampleI() ws.image = image ws.well = well well.addWellSample(ws) ws = self.update.saveAndReturnObject(ws) return plate, well, ws.image def test_spw_download(self, image_well_plate): """ Download of an Image that is part of a plate should be disabled, and return a 404 response. """ plate, well, image = image_well_plate # download archived files request_url = reverse('webgateway.views.archived_files') data = { "image": image.id.val } _get_response(self.django_client, request_url, data, status_code=404) def test_orphaned_image_direct_download(self): """ Download of archived files for a non-SPW orphaned Image. """ image = self.importSingleImage() # download archived files request_url = reverse('webgateway.views.archived_files', args=[image.id.val]) _get_response(self.django_client, request_url, {}, status_code=200) def test_orphaned_image_download(self): """ Download of archived files for a non-SPW orphaned Image. """ image = self.importSingleImage() # download archived files request_url = reverse('webgateway.views.archived_files') data = { "image": image.id.val } _get_response(self.django_client, request_url, data, status_code=200) def test_image_in_dataset_download(self): """ Download of archived files for a non-SPW Image in Dataset. """ image = self.importSingleImage() ds = self.make_dataset() self.link(ds, image) # download archived files request_url = reverse('webgateway.views.archived_files') data = { "image": image.id.val } _get_response(self.django_client, request_url, data, status_code=200) def test_image_in_dataset_in_project_download(self): """ Download of archived files for a non-SPW Image in Dataset in Project. """ image = self.importSingleImage() ds = self.make_dataset() pr = self.make_project() self.link(pr, ds) self.link(ds, image) # download archived files request_url = reverse('webgateway.views.archived_files') data = { "image": image.id.val } _get_response(self.django_client, request_url, data, status_code=200) def test_well_download(self, image_well_plate): """ Download of archived files for a SPW Well. """ plate, well, image = image_well_plate # download archived files request_url = reverse('webgateway.views.archived_files') data = { "well": well.id.val } _get_response(self.django_client, request_url, data, status_code=404) def test_attachement_download(self): """ Download of attachement. """ image = self.importSingleImage() fa = self.make_file_annotation() self.link(image, fa) # download archived files request_url = reverse('download_annotation', args=[fa.id.val]) _get_response(self.django_client, request_url, {}, status_code=200)

gpl-2.0

uhjish/bx-python

lib/bx/seq/nib.py

3

2884

""" Classes to support nib files. :Author: James Taylor (james@bx.psu.edu), Bob Harris (rsharris@bx.psu.edu) A nib sequence is a sequence of DNA, using the 10 character alphabet A,C,G,T,N (upper and lower case). The file is packed as 4 bits per character. nib file format --------------- Fields can be in big- or little-endian format; they must match the endianess of the magic number. ============ =========== ====================================================== offset 0x00: 6B E9 3D 3A big endian magic number (3A 3D E9 6B => little endian) offset 0x04: xx xx xx xx length of data sequence (counted in characters) offset 0x08: ... data sequence; most significant nybble in each byte is first in sequence ============ =========== ====================================================== """ from __future__ import division from bx.seq.seq import SeqFile,SeqReader import sys, struct, string, math import _nib NIB_MAGIC_NUMBER = 0x6BE93D3A NIB_MAGIC_NUMBER_SWAP = 0x3A3DE96B NIB_MAGIC_SIZE = 4 NIB_LENGTH_SIZE = 4 class NibFile(SeqFile): def __init__(self, file, revcomp=False, name="", gap=None): SeqFile.__init__(self,file,revcomp,name,gap) self.byte_order = ">" magic = struct.unpack(">L", file.read(NIB_MAGIC_SIZE))[0] if (magic != NIB_MAGIC_NUMBER): if magic == NIB_MAGIC_NUMBER_SWAP: self.byte_order = "<" else: raise Exception("Not a NIB file") self.magic = magic self.length = struct.unpack("%sL" % self.byte_order, file.read(NIB_LENGTH_SIZE))[0] def raw_fetch(self, start, length): # Check parameters assert start >= 0, "Start must be greater than 0" assert length >= 0, "Length must be greater than 0" assert start + length <= self.length, "Interval beyond end of sequence" # Read block of bytes containing sequence block_start = int(math.floor(start / 2)) block_end = int(math.floor((start + length - 1) / 2)) block_len = block_end + 1 - block_start self.file.seek(NIB_MAGIC_SIZE + NIB_LENGTH_SIZE + block_start) raw = self.file.read(block_len) # Unpack compressed block into a character string and return return _nib.translate_raw_data( raw, start, length ) class NibReader(SeqReader): def __init__(self, file, revcomp=False, name="", gap=None): SeqReader.__init__(self,file,revcomp,name,gap) def next(self): if (self.seqs_read != 0): return # nib files have just one sequence seq = NibFile(self.file,self.revcomp,self.name,self.gap) self.seqs_read += 1 return seq class NibWriter(object): def __init__(self,file): self.file = file def write(self,seq): assert (False), "NibWriter.write() is not implemented yet" def close(self): self.file.close()

mit

trichter/sito

xcorr.py

1

17828

#!/usr/bin/env python # by TR #import logging from obspy.signal.util import nextpow2 from scipy.fftpack import fft, ifft, fftshift, ifftshift from sito._xcorr import xcorr as xcorr_c from sito.util import isnumber, filterResp, smooth, fillArray import logging import numpy as np import obspy.signal from obspy.core.util.decorator import deprecated USE_FFTW3 = False #fft = None #ifft = None #def use_fftw3(val=True): # global USE_FFTW3, fft, ifft # USE_FFTW3 = val # print('not ' * (not val) + 'using FFWT3 library.') # if val: # from sito.util.fftw3_be import fft, ifft # else: # from scipy.fftpack import fft, ifft #use_fftw3(USE_FFTW3) log = logging.getLogger(__name__) def timeNorm(data, method=None, param=None, recursive=0): """ Calculates normalized data. See Bensen et al.(2007) Method is a string. There are the following methods: 1bit: reduce data to +1 if >0 and -1 if <0 clip: clip data to the root mean square (rms) eventremoval: automatic event detection and removal - if an value is bigger than the threshold, the following values are set to zero. param: (threshold, number of samples (eg. 30min) to set to zero) stalta: automatic event removing with recursive sta/lta trigger runningmean: the data is normalized with the running average The width of the normalization window determines how much amplitude information is retained (N=1 -> 1bit normalization, N very big -> rescaled data). Half of the maximum period of the passband filter_ works well. param: width of window (should be odd) runningmean_over_filtered: the data is normalized with the running average over the filtered data. A band pass filter_ between 20s and 100s period can remove local seismicity. param: (width of window in seconds, sampling rate, filter_, freq1, freq2) filter_: in ('band', 'low', high') if filter_ in ('low', 'high') only on frequency is needed waterlevel: any amplitude above the waterlevel (multiple of rms) is down-weighted by a factor. This procedure is repeated all of the waveform data is under the water-level param: (water-level factor, reducing factor) """ mask = np.ma.getmask(data) if method == '1bit': data = np.sign(data) elif method == 'clip': std = np.std(data) data[data > std] = std data[data < -std] = -std elif method == 'eventremoval': if param == None: # remove 30 min (at 10Hz) after events if data is bigger than 2000 param = (2000, 30 * 60 * 10) clip = np.nonzero(abs(data) >= param[0])[0] if len(clip) > 0: clip = clip[0] index = min(clip + param[1], len(data)) data[clip:index] = 0 if index < len(data): data[index:] = timeNorm(data[index:], method=method, param=param) elif method == 'stalta': if param is None: # STA: 3s at 100Hz, LTA: 10s, trigger on: 1.2, trigger off:1.0 param = (100 * 3, 100 * 10, 1.2, 1.0) cft = obspy.signal.trigger.recSTALTA(data, param[0], param[1]) trg = obspy.signal.trigger.triggerOnset(cft, param[2], param[3]) for on, off in trg: data[on:off] = 0 elif method == 'runningmean': if param == None: # smooth over 20s at 10Hz param = 10 * 10 smoothed = smooth(np.abs(data), param) data /= smoothed elif method == 'runningmean_over_filtered': if param is None: # smooth over 20s at 10Hz over bandpassed data param = (10, 10, 'band', 1 / 50., 1 / 15.) sr = param[1] over = int(param[0] * sr) filter_ = param[2] if filter_ == 'band': data2 = obspy.signal.bandpass(data, param[3], param[4], sr) elif filter_ == 'low': data2 = obspy.signal.lowpass(data, param[3], sr) elif filter_ == 'high': data2 = obspy.signal.highpass(data, param[3], sr) else: raise ValueError("filter_ should be in ('band', 'high', 'low')") data /= smooth(np.abs(data2), over) elif method == 'waterlevel': if param == None: # data above 6*rms is recursively reduced by a factor of 10 param = (6., 10.) waterlevel = param[0] * np.std(data) indices = np.abs(data) > waterlevel if np.any(indices): if param[1] == 0: data[indices] = 0 else: data[indices] /= param[1] data = timeNorm(data, method=method, param=param, recursive=recursive + 1) elif method == 'waterlevel_rm': if param == None: # running mean over 5s at 10Hz data # data above 4*rms is recursively reduced by a factor of 10 param = (5 * 10, 4., 10.) running_mean = smooth(np.abs(data), param[0]) waterlevel = param[1] * np.std(running_mean) indices = (running_mean > waterlevel) + (np.abs(data) > waterlevel) if np.any(indices): param = list(param) frac_zeros = 1. * np.count_nonzero(indices) / len(data) if param[2] == 0: data[indices] = 0 param[1] *= (1 + frac_zeros) else: data[indices] /= param[2] param[1] *= (1 + frac_zeros * (1 - 1 / param[2])) print recursive, frac_zeros, waterlevel data = timeNorm(data, method=method, param=param, recursive=recursive + 1) elif method == 'waterlevel_env': if param == None: # data above 4*rms is recursively reduced by a factor of 10 param = (4., 10.) param = list(param) if len(param) == 2: param.append(0) param.append(0) env = obspy.signal.cpxtrace.envelope(data)[1][:len(data)] # correct std because of zeros waterlevel = param[0] * np.std(env) / (1 - param[2]) # import pylab as plt # from imaging import plotTrace # from sito import Trace # trace = Trace(data=data) # trace2 = Trace(data=env) # plotTrace(trace) # plotTrace(trace2) # plt.figure() # plt.plot(data) # plt.plot(env) # plt.hlines(waterlevel, 0, len(data)) # plt.show() indices = env > waterlevel frac_zeros = 1. * np.count_nonzero(indices) / len(data) if np.any(indices) and frac_zeros > 0.0005 and param[3] < 20: if param[1] == 0: data[indices] = 0 #param[0] *= (1 + frac_zeros) else: data[indices] /= param[2] #param[0] *= (1 + frac_zeros * (1 - 1 / param[1])) print param[3], frac_zeros, param[2], waterlevel param[2] += frac_zeros param[3] += 1 data = timeNorm(data, method=method, param=param) elif method == 'waterlevel_env2': if param == None: # data above 4*rms is recursively reduced by a factor of 10 param = (4., 10.) N = len(data) env = obspy.signal.cpxtrace.envelope(data)[1][:N] if mask is not False: env[mask] = 0. num_stds = 96 # 24*4 =^ every 15min if N < 86400: # 24*3600 num_stds = N // 900 len_parts = N // num_stds # N//96 = N//24//4 =^ 15min len_stds = len_parts // 15 # len_parts//15 =^ 1min stds = np.array([np.std(env[i:i + len_stds]) for i in np.arange(num_stds) * len_parts]) if np.min(stds) == 0: stds = stds[stds != 0.] num_stds = len(stds) stds = np.sort(stds)[num_stds // 15:-num_stds // 15] stds = stds[stds < np.min(stds) * 2.] waterlevel = param[0] * np.mean(stds) # import pylab as plt # from imaging import plotTrace # from sito import Trace # trace = Trace(data=data) # trace2 = Trace(data=env) # plotTrace(trace) # plotTrace(trace2) # plt.figure() # plt.plot(data) # plt.plot(env) # plt.hlines(waterlevel, 0, len(data)) # plt.show() indices = env > waterlevel #frac_zeros = 1. * np.count_nonzero(indices) / len(data) if np.any(indices): if param[1] == 0: # not setting values to zero but masking them # -> they will stay zero after spectral whitening # and 1bit normalization mask = np.ma.mask_or(mask, indices) #data[indices] = 0 else: data[indices] /= param[2] elif method is not None: raise ValueError('The method passed to timeNorm() is not known.') return fillArray(data, mask=mask, fill_value=0.) def spectralWhitening(data, sr=None, smoothi=None, freq_domain=False, apply_filter=None): """ Apply spectral whitening to data. sr: sampling rate (only needed for smoothing) smoothi: None or int Data is divided by its smoothed (Default: None) amplitude spectrum. """ if freq_domain: mask = False spec = data else: mask = np.ma.getmask(data) N = len(data) nfft = nextpow2(N) spec = fft(data, nfft) #df = sr/N spec_ampl = np.sqrt(np.abs(np.multiply(spec, np.conjugate(spec)))) if isinstance(smoothi, basestring) and isnumber(smoothi) and smoothi > 0: smoothi = int(smoothi * N / sr) spec /= ifftshift(smooth(fftshift(spec_ampl), smoothi)) else: spec /= spec_ampl if apply_filter is not None: spec *= filterResp(*apply_filter, sr=sr, N=len(spec), whole=True)[1] if freq_domain: return spec else: ret = np.real(ifft(spec, nfft)[:N]) if USE_FFTW3: ret = ret.copy() return fillArray(ret, mask=mask, fill_value=0.) # from pylab import plot, show, subplot # freqs = np.fft.fftfreq(nfft, 1. / sr) # ax = subplot(211) ## ax.set_xscale('log') ## ax.set_yscale('log') # plot(freqs, spec_ampl) # plot(freqs, ifftshift(smooth(fftshift(spec_ampl), over)), lw=2) # ax2 = subplot(212, sharex=ax) ## ax2.set_xscale('log') ## ax2.set_yscale('log') # plot(freqs, np.abs(spec * np.conjugate(spec)) ** 0.5) # plot(freqs, np.ones(nfft), lw=2) # show() # return np.abs(ifft(spec, nfft)[:N]) def xcorrf(data1, data2, shift=None, shift_zero=0, oneside=False, demean=True, window=0, ndat1d=0, ndat2d=0, N1=None, N2=None, normalize=True, freq_domain=False, transform_back=True, stdev1=None, stdev2=None): """ Cross-correlation of numpy arrays data1 and data2 in frequency domain. We define cross-corelation as: xcorr[i] = sum_j (tr1[i+j-shift_zero] * tr2[j]) The data is demeaned before cross-correlation and the result normalized after cross-correlation. data1, data2: data shift: maximum samples to shift (window for i in the above formula) shift_zero: shift tr1 before cross-correlation by this amount of samples to the right (this means correlation function is shifted to the right or better: the window of what you get of the function is shifted to the left) oneside: if True only the right/positive side of the correlation function is returned. Overrides parameter shift_zero. demean: if True demean data beforehand normalize: if True normalize correlation function (1 means perfect correlation) window: Use only data in this window for demeaning and normalizing 0: window = min(ndat1, ndat2) >0: window = this parameter ndat1d, ndat2d: If >0 use different values for the length of the arrays when calculating the mean (defaults to window parameter) return: numpy array with correlation function of length 2*shift+1 for oneside=False and of length shift+1 for oneside=True """ if freq_domain and not transform_back: return data1 * np.conjugate(data2) elif freq_domain: min_size = max(2 * shift + 1 + abs(shift_zero), (N1 + N2) // 2 + shift + abs(shift_zero)) if len(data1) < min_size: raise ValueError('NFFT was not large enough to cover the desired ' 'xcorr!\nnfft: %d, required minimum: %d' % (len(data1), min_size)) ret = (ifft(data1 * np.conjugate(data2))).real else: complex_result = (data1.dtype == np.complex or data2.dtype == np.complex) N1 = len(data1) N2 = len(data2) #if isinstance(data1[0], np.integer) or isinstance(data2[0], np.integer): data1 = data1.astype('float64') data2 = data2.astype('float64') #if (N1-N2)%2==1: # raise ValueError('(N1-N2)%2 has to be 0') if window == 0: window = min(N1, N2) if ndat1d == 0: ndat1d = window if ndat2d == 0: ndat2d = window # determine indices for demeaning and normalization ind1 = max(0, (N1 - window) // 2) ind2 = min(N1, (N1 + window) // 2) ind3 = max(0, (N2 - window) // 2) ind4 = min(N2, (N2 + window) // 2) # demean and normalize data if demean: data1 -= np.sum(data1[ind1:ind2]) / ndat1d data2 -= np.sum(data2[ind3:ind4]) / ndat2d if normalize: data1 /= np.max(data1[ind1:ind2]) data2 /= np.max(data2[ind3:ind4]) # Always use 2**n-sized FFT, perform xcorr size = max(2 * shift + 1 + abs(shift_zero), (N1 + N2) // 2 + shift + abs(shift_zero)) nfft = nextpow2(size) IN1 = fft(data1, nfft) if USE_FFTW3: IN1 = IN1.copy() IN1 *= np.conjugate(fft(data2, nfft)) ret = ifft(IN1) if not USE_FFTW3: del IN1 if not complex_result: ret = ret.real # shift data for time lag 0 to index 'shift' ret = np.roll(ret, -(N1 - N2) // 2 + shift + shift_zero)[:2 * shift + 1] # normalize xcorr if normalize: if not freq_domain: stdev1 = (np.sum(data1[ind1:ind2] ** 2)) ** 0.5 stdev2 = (np.sum(data2[ind3:ind4] ** 2)) ** 0.5 # stdev1 = (np.sum(data1 ** 2)) ** 0.5 # stdev2 = (np.sum(data2 ** 2)) ** 0.5 if stdev1 == 0 or stdev2 == 0: log.warning('Data is zero!!') ret[:] = 0. else: ret /= stdev1 * stdev2 if oneside: ret = ret[shift:] return np.copy(ret) def acorrf(data, shift, oneside=True, clipdata=False, ** kwargs): """ Auto-correlation of array data in frequency domain. clipdata: if True: data2=data[shift:-shift] if False: data2=data It calls xcorrf. See doc for xcorr: """ if clipdata: data2 = data[shift:-shift] else: data2 = data return xcorrf(data, data2, shift, oneside=oneside, ** kwargs) @deprecated def xcorr_obspy(data1, data2, shift): """Cross correlation using ObsPy""" return obspy.signal.xcorr(data1, data2, shift, full_xcorr=True)[2] @deprecated def xcorrt(data1, data2, shift, shift_zero=0, oneside=False, demean=True, normalize=True, window=0, ndat1d=0, ndat2d=0): """ Cross-correlation of numpy arrays data1 and data2 in time domain. """ if (len(data1) - len(data2)) % 2 == 1: raise ValueError('(N1-N2)%2 has to be 0') if oneside: ret = xcorr_c(data1, data2, (shift + 1) // 2, -((shift + 1) // 2), window, bool(demean), bool(normalize), ndat1d, ndat2d) if len(ret) == shift + 2: ret = ret[:-1] else: ret = xcorr_c(data1, data2, shift, shift_zero, window, bool(demean), bool(normalize), ndat1d, ndat2d) return ret @deprecated def acorrt(data, shift, oneside=True, clipdata=True, ** kwargs): """ Auto-correlation of array data in time domain. clipdata: if True: data2=data[shift:-shift] if False: data2=data It calls xcorrt with parameter oneside=True. See doc for xcorr: """ if clipdata: data2 = data[shift:-shift] else: data2 = data ret = xcorrt(data, data2, shift, oneside=True, ** kwargs) if not oneside: ret = np.hstack((ret[::-1], ret[1:])) return ret def getNormFactors(data1, data2, demean=True, num=24): """ return norm factors of xcorr routine of divided data compared to whole set The norm factors of the xcorr routine are calculated for the data divided into 'num' parts of the data set (each with equal length) and for the whole data set and the quotient is returned. Only if these are near 1 stacking the xcorr is technically correct. """ N = len(data1) if len(data2) != N: raise ValueError('Length of data1 has to be the same as length of data2') if isinstance(data1[0], np.integer) or isinstance(data2[0], np.integer): data1 = 1. * data1 data2 = 1. * data2 if demean: data1 -= np.mean(data1) data2 -= np.mean(data2) fac_whole_time = (np.sum(data1 ** 2) * np.sum(data2 ** 2)) ** 0.5 fac_period = np.zeros(num) for i in range(num): ind1 = i * N // num ind2 = (i + 1) * N // num data1p = data1[ind1:ind2] - np.mean(data1[ind1:ind2]) data2p = data2[ind1:ind2] - np.mean(data2[ind1:ind2]) fac_period[i] = (np.sum(data1p ** 2) * np.sum(data2p ** 2)) ** 0.5 fac_period = fac_period * num / fac_whole_time return fac_period

mit

lepisma/audire

src/server.py

1

1838

""" Tornado websocket server """ import tornado.ioloop import tornado.web import tornado.websocket import os from threading import Thread from modules import noise, anomaly, message, event settings = {"static_path": os.path.join(os.path.dirname(__file__), "static")} # Runt the audio level thread Thread(target=noise.noise_level).start() class IndexHandler(tornado.web.RequestHandler): """Handle rendering of dash """ def get(self): self.render("index.html") class EventHandler(tornado.web.RequestHandler): """Event detection route handler """ def get(self): # Event detection results self.write(event.get_event()) class LevelHandler(tornado.web.RequestHandler): """Audio Level request handler """ def get(self): # Make a global level var # Update it using a threaded script # Return its value here self.write(str(noise.level)) class WebSocketHandler(tornado.websocket.WebSocketHandler): """ Handle messages from server to dash. Work involves sending anomaly values and speech to text values. """ def open(self): print("WebSocket Opened") # Pass the object to different modules # so that they can communicate with the dash Thread(target=anomaly.anomaly_detection, args=(self, )).start() Thread(target=message.speech_win, args=(self, )).start() def on_message(self, message): print("Received a message : " + message) def on_close(self): print("WebSocket closed") application = tornado.web.Application([ (r"/", IndexHandler), (r"/event", EventHandler), (r"/level", LevelHandler), (r"/ws", WebSocketHandler) ], **settings) if __name__ == "__main__": application.listen(5000) tornado.ioloop.IOLoop.instance().start()

gpl-3.0

mola/qgis

python/plugins/GdalTools/tools/doRasterize.py

3

4207

# -*- coding: utf-8 -*- from PyQt4.QtCore import * from PyQt4.QtGui import * from qgis.core import * from qgis.gui import * from osgeo import ogr from ui_widgetRasterize import Ui_GdalToolsWidget as Ui_Widget from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget import GdalTools_utils as Utils class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget): def __init__(self, iface): QWidget.__init__(self) self.iface = iface self.setupUi(self) BasePluginWidget.__init__(self, self.iface, "gdal_rasterize") self.lastEncoding = Utils.getLastUsedEncoding() self.setParamsStatus( [ (self.inputLayerCombo, [SIGNAL("currentIndexChanged(int)"), SIGNAL("editTextChanged(const QString &)")] ), (self.outputFileEdit, SIGNAL("textChanged(const QString &)")), (self.attributeComboBox, SIGNAL("currentIndexChanged(int)")) ] ) self.connect(self.selectInputFileButton, SIGNAL("clicked()"), self.fillInputFileEdit) self.connect(self.selectOutputFileButton, SIGNAL("clicked()"), self.fillOutputFileEdit) self.connect(self.inputLayerCombo, SIGNAL("currentIndexChanged(int)"), self.fillFieldsCombo) # fill layers combo self.fillInputLayerCombo() def fillInputLayerCombo( self ): self.inputLayerCombo.clear() ( self.layers, names ) = Utils.getVectorLayers() self.inputLayerCombo.addItems( names ) def fillFieldsCombo(self): index = self.inputLayerCombo.currentIndex() if index < 0: return self.lastEncoding = self.layers[index].dataProvider().encoding() self.loadFields( self.getInputFileName() ) def fillInputFileEdit(self): lastUsedFilter = Utils.FileFilter.lastUsedVectorFilter() inputFile, encoding = Utils.FileDialog.getOpenFileName(self, self.tr( "Select the input file for Rasterize" ), Utils.FileFilter.allVectorsFilter(), lastUsedFilter, True) if inputFile.isEmpty(): return Utils.FileFilter.setLastUsedVectorFilter(lastUsedFilter) self.inputLayerCombo.setCurrentIndex(-1) self.inputLayerCombo.setEditText(inputFile) self.lastEncoding = encoding self.loadFields( inputFile ) def fillOutputFileEdit(self): lastUsedFilter = Utils.FileFilter.lastUsedRasterFilter() outputFile = Utils.FileDialog.getOpenFileName(self, self.tr( "Select the raster file to save the results to" ), Utils.FileFilter.allRastersFilter(), lastUsedFilter) if outputFile.isEmpty(): return Utils.FileFilter.setLastUsedRasterFilter(lastUsedFilter) self.outputFileEdit.setText(outputFile) def getArguments(self): arguments = QStringList() if self.attributeComboBox.currentIndex() >= 0: arguments << "-a" arguments << self.attributeComboBox.currentText() if self.inputLayerCombo.currentIndex() >= 0: arguments << "-l" arguments << QFileInfo(self.layers[ self.inputLayerCombo.currentIndex() ].source()).baseName() elif not self.inputLayerCombo.currentText().isEmpty(): arguments << "-l" arguments << QFileInfo(self.inputLayerCombo.currentText()).baseName() arguments << self.getInputFileName() arguments << self.outputFileEdit.text() return arguments def getInputFileName(self): if self.inputLayerCombo.currentIndex() >= 0: return self.layers[self.inputLayerCombo.currentIndex()].source() return self.inputLayerCombo.currentText() def getOutputFileName(self): return self.outputFileEdit.text() def addLayerIntoCanvas(self, fileInfo): self.iface.addRasterLayer(fileInfo.filePath()) def loadFields(self, vectorFile): self.attributeComboBox.clear() if vectorFile.isEmpty(): return try: (fields, names) = Utils.getVectorFields(vectorFile) except Exception, e: QErrorMessage(self).showMessage( str(e) ) self.inputLayerCombo.clearEditText() self.inputLayerCombo.setCurrentIndex(-1) return ncodec = QTextCodec.codecForName(self.lastEncoding) for name in names: self.attributeComboBox.addItem( ncodec.toUnicode(name) )

gpl-2.0