text
stringlengths 6
947k
| repo_name
stringlengths 5
100
| path
stringlengths 4
231
| language
stringclasses 1
value | license
stringclasses 15
values | size
int64 6
947k
| score
float64 0
0.34
|
|---|---|---|---|---|---|---|
import pyaf.Bench.TS_datasets as tsds
import tests.artificial.process_artificial_dataset as art
art.process_dataset(N = 1024 , FREQ = 'D', seed = 0, trendtype = "PolyTrend", cycle_length = 7, transform = "RelativeDifference", sigma = 0.0, exog_count = 20, ar_order = 0); | antoinecarme/pyaf | tests/artificial/transf_RelativeDifference/trend_PolyTrend/cycle_7/ar_/test_artificial_1024_RelativeDifference_PolyTrend_7__20.py | Python | bsd-3-clause | 274 | 0.083942 |
# -*- coding: utf-8 -*-
from __future__ import print_function, unicode_literals
import pytest
from django import forms
from django.http import QueryDict
from test_project.one_to_one.models import Restaurant, Waiter
from url_filter.backends.django import DjangoFilterBackend
from url_filter.filters import Filter
from url_filter.filtersets.base import FilterSet, StrictMode
from url_filter.utils import FilterSpec
class TestFilterSet(object):
def test_init(self):
fs = FilterSet(
data='some data',
queryset='queryset',
context={'context': 'here'},
strict_mode=StrictMode.fail,
)
assert fs.data == 'some data'
assert fs.queryset == 'queryset'
assert fs.context == {'context': 'here'}
assert fs.strict_mode == StrictMode.fail
def test_get_filters(self):
class TestFilterSet(FilterSet):
foo = Filter(form_field=forms.CharField())
filters = TestFilterSet().get_filters()
assert isinstance(filters, dict)
assert list(filters.keys()) == ['foo']
assert isinstance(filters['foo'], Filter)
assert filters['foo'].parent is None
def test_filters(self):
class TestFilterSet(FilterSet):
foo = Filter(form_field=forms.CharField())
fs = TestFilterSet()
filters = fs.filters
assert isinstance(filters, dict)
assert list(filters.keys()) == ['foo']
assert isinstance(filters['foo'], Filter)
assert filters['foo'].parent is fs
assert filters['foo'].name == 'foo'
def test_default_filter_no_default(self):
class TestFilterSet(FilterSet):
foo = Filter(form_field=forms.CharField())
assert TestFilterSet().default_filter is None
def test_default_filter(self):
class TestFilterSet(FilterSet):
foo = Filter(form_field=forms.CharField(), is_default=True)
bar = Filter(form_field=forms.CharField())
default = TestFilterSet().default_filter
assert isinstance(default, Filter)
assert default.name == 'foo'
def test_validate_key(self):
assert FilterSet().validate_key('foo') is None
assert FilterSet().validate_key('foo__bar') is None
assert FilterSet().validate_key('foo__bar!') is None
with pytest.raises(forms.ValidationError):
FilterSet().validate_key('f!oo')
def test_get_filter_backend(self):
backend = FilterSet().get_filter_backend()
assert isinstance(backend, DjangoFilterBackend)
def test_filter_no_queryset(self):
fs = FilterSet()
with pytest.raises(AssertionError):
fs.filter()
def test_filter_data_not_querydict(self):
fs = FilterSet(queryset=[])
with pytest.raises(AssertionError):
fs.filter()
def test_get_specs(self):
class BarFilterSet(FilterSet):
other = Filter(source='stuff',
form_field=forms.CharField(),
default_lookup='contains')
thing = Filter(form_field=forms.IntegerField(min_value=0, max_value=15))
class FooFilterSet(FilterSet):
field = Filter(form_field=forms.CharField())
bar = BarFilterSet()
def _test(data, expected, **kwargs):
fs = FooFilterSet(
data=QueryDict(data),
queryset=[],
**kwargs
)
assert set(fs.get_specs()) == set(expected)
_test('field=earth&bar__other=mars', [
FilterSpec(['field'], 'exact', 'earth', False),
FilterSpec(['bar', 'stuff'], 'contains', 'mars', False),
])
_test('field!=earth&bar__other=mars', [
FilterSpec(['field'], 'exact', 'earth', True),
FilterSpec(['bar', 'stuff'], 'contains', 'mars', False),
])
_test('field__in=earth,pluto&bar__other__icontains!=mars', [
FilterSpec(['field'], 'in', ['earth', 'pluto'], False),
FilterSpec(['bar', 'stuff'], 'icontains', 'mars', True),
])
_test('fields__in=earth,pluto&bar__other__icontains!=mars', [
FilterSpec(['bar', 'stuff'], 'icontains', 'mars', True),
])
_test('field__in=earth,pluto&bar__ot!her__icontains!=mars', [
FilterSpec(['field'], 'in', ['earth', 'pluto'], False),
])
_test('bar__thing=5', [
FilterSpec(['bar', 'thing'], 'exact', 5, False),
])
_test('bar__thing__in=5,10,15', [
FilterSpec(['bar', 'thing'], 'in', [5, 10, 15], False),
])
_test('bar__thing__range=5,10', [
FilterSpec(['bar', 'thing'], 'range', [5, 10], False),
])
_test('bar=5', [])
_test('bar__thing__range=5,10,15', [])
_test('bar__thing=100', [])
_test('bar__thing__in=100,5', [])
with pytest.raises(forms.ValidationError):
_test('bar__thing__in=100,5', [], strict_mode=StrictMode.fail)
def test_filter_one_to_one(self, one_to_one):
class PlaceFilterSet(FilterSet):
pk = Filter(form_field=forms.IntegerField(min_value=0), is_default=True)
name = Filter(form_field=forms.CharField(max_length=50))
address = Filter(form_field=forms.CharField(max_length=80))
class RestaurantFilterSet(FilterSet):
pk = Filter(form_field=forms.IntegerField(min_value=0), is_default=True)
place = PlaceFilterSet()
serves_hot_dogs = Filter(form_field=forms.BooleanField(required=False))
serves_pizza = Filter(form_field=forms.BooleanField(required=False))
class WaiterFilterSet(FilterSet):
pk = Filter(form_field=forms.IntegerField(min_value=0), is_default=True)
restaurant = RestaurantFilterSet()
name = Filter(form_field=forms.CharField(max_length=50))
def _test(fs, data, qs, expected, count):
_fs = fs(
data=QueryDict(data),
queryset=qs,
)
filtered = _fs.filter()
assert filtered.count() == count
assert set(filtered) == set(expected)
_test(
RestaurantFilterSet,
'place__name__startswith=Demon',
Restaurant.objects.all(),
Restaurant.objects.filter(place__name__startswith='Demon'),
1
)
_test(
RestaurantFilterSet,
'place__address__contains!=Ashland',
Restaurant.objects.all(),
Restaurant.objects.exclude(place__address__contains='Ashland'),
1
)
_test(
WaiterFilterSet,
'restaurant__place__pk=1',
Waiter.objects.all(),
Waiter.objects.filter(restaurant__place=1),
2
)
_test(
WaiterFilterSet,
'restaurant__place=1',
Waiter.objects.all(),
Waiter.objects.filter(restaurant__place=1),
2
)
_test(
WaiterFilterSet,
'restaurant__place__name__startswith=Demon',
Waiter.objects.all(),
Waiter.objects.filter(restaurant__place__name__startswith="Demon"),
2
)
_test(
WaiterFilterSet,
('restaurant__place__name__startswith=Demon'
'&name__icontains!=jon'),
Waiter.objects.all(),
(Waiter.objects
.filter(restaurant__place__name__startswith="Demon")
.exclude(name__icontains='jon')),
1
)
| AlexandreProenca/django-url-filter | tests/filtersets/test_base.py | Python | mit | 7,675 | 0.000782 |
# encoding: utf-8
#
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
#
# Author: Kyle Lahnakoski (kyle@lahnakoski.com)
#
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
from collections import Mapping
from mo_logs import Log
from mo_dots import set_default, wrap, split_field, join_field, concat_field
from mo_math import Math
from pyLibrary.queries.domains import is_keyword
from pyLibrary.queries.expressions import Expression
from pyLibrary.queries.namespace import convert_list, Namespace
from pyLibrary.queries.query import QueryOp
from mo_times.dates import Date
class Typed(Namespace):
"""
NOTE: USING THE ".$value" SUFFIX IS DEPRECIATED: CURRENT VERSIONS OF ES ARE STRONGLY TYPED, LEAVING NO
CASE WHERE A GENERAL "value" IS USEFUL. WE WOULD LIKE TO MOVE TO ".$number", ".$string", ETC. FOR
EACH TYPE, LIKE WE DO WITH DATABASES
"""
def __init__(self):
self.converter_map = {
"and": self._convert_many,
"or": self._convert_many,
"not": self.convert,
"missing": self.convert,
"exists": self.convert
}
def convert(self, expr):
"""
ADD THE ".$value" SUFFIX TO ALL VARIABLES
"""
if isinstance(expr, Expression):
vars_ = expr.vars()
rename = {v: concat_field(v, "$value") for v in vars_}
return expr.map(rename)
if expr is True or expr == None or expr is False:
return expr
elif Math.is_number(expr):
return expr
elif expr == ".":
return "."
elif is_keyword(expr):
#TODO: LOOKUP SCHEMA AND ADD ALL COLUMNS WITH THIS PREFIX
return expr + ".$value"
elif isinstance(expr, basestring):
Log.error("{{name|quote}} is not a valid variable name", name=expr)
elif isinstance(expr, Date):
return expr
elif isinstance(expr, QueryOp):
return self._convert_query(expr)
elif isinstance(expr, Mapping):
if expr["from"]:
return self._convert_query(expr)
elif len(expr) >= 2:
#ASSUME WE HAVE A NAMED STRUCTURE, NOT AN EXPRESSION
return wrap({name: self.convert(value) for name, value in expr.items()})
else:
# ASSUME SINGLE-CLAUSE EXPRESSION
k, v = expr.items()[0]
return self.converter_map.get(k, self._convert_bop)(k, v)
elif isinstance(expr, (list, set, tuple)):
return wrap([self.convert(value) for value in expr])
def _convert_query(self, query):
output = QueryOp("from", None)
output.select = self._convert_clause(query.select)
output.where = self.convert(query.where)
output.frum = self._convert_from(query.frum)
output.edges = self._convert_clause(query.edges)
output.groupby = self._convert_clause(query.groupby)
output.window = convert_list(self._convert_window, query.window)
output.having = convert_list(self._convert_having, query.having)
output.sort = self._convert_clause(query.sort)
output.limit = query.limit
output.format = query.format
return output
def _convert_clause(self, clause):
"""
JSON QUERY EXPRESSIONS HAVE MANY CLAUSES WITH SIMILAR COLUMN DELCARATIONS
"""
if clause == None:
return None
elif isinstance(clause, Mapping):
return set_default({"value": self.convert(clause["value"])}, clause)
else:
return [set_default({"value": self.convert(c.value)}, c) for c in clause]
def _convert_from(self, frum):
return frum
def _convert_having(self, having):
raise NotImplementedError()
def _convert_window(self, window):
raise NotImplementedError()
def _convert_many(self, k, v):
return {k: map(self.convert, v)}
def _convert_bop(self, op, term):
if isinstance(term, list):
return {op: map(self.convert, term)}
return {op: {var: val for var, val in term.items()}}
| klahnakoski/esReplicate | pyLibrary/queries/namespace/typed.py | Python | mpl-2.0 | 4,356 | 0.002525 |
############################################################
#
# Autogenerated by the KBase type compiler -
# any changes made here will be overwritten
#
############################################################
try:
import json as _json
except ImportError:
import sys
sys.path.append('simplejson-2.3.3')
import simplejson as _json
import requests as _requests
import urlparse as _urlparse
import random as _random
import base64 as _base64
from ConfigParser import ConfigParser as _ConfigParser
import os as _os
_CT = 'content-type'
_AJ = 'application/json'
_URL_SCHEME = frozenset(['http', 'https'])
def _get_token(user_id, password,
auth_svc='https://nexus.api.globusonline.org/goauth/token?' +
'grant_type=client_credentials'):
# This is bandaid helper function until we get a full
# KBase python auth client released
auth = _base64.encodestring(user_id + ':' + password)
headers = {'Authorization': 'Basic ' + auth}
ret = _requests.get(auth_svc, headers=headers, allow_redirects=True)
status = ret.status_code
if status >= 200 and status <= 299:
tok = _json.loads(ret.text)
elif status == 403:
raise Exception('Authentication failed: Bad user_id/password ' +
'combination for user %s' % (user_id))
else:
raise Exception(ret.text)
return tok['access_token']
def _read_rcfile(file=_os.environ['HOME'] + '/.authrc'): # @ReservedAssignment
# Another bandaid to read in the ~/.authrc file if one is present
authdata = None
if _os.path.exists(file):
try:
with open(file) as authrc:
rawdata = _json.load(authrc)
# strip down whatever we read to only what is legit
authdata = {x: rawdata.get(x) for x in (
'user_id', 'token', 'client_secret', 'keyfile',
'keyfile_passphrase', 'password')}
except Exception, e:
print "Error while reading authrc file %s: %s" % (file, e)
return authdata
def _read_inifile(file=_os.environ.get( # @ReservedAssignment
'KB_DEPLOYMENT_CONFIG', _os.environ['HOME'] +
'/.kbase_config')):
# Another bandaid to read in the ~/.kbase_config file if one is present
authdata = None
if _os.path.exists(file):
try:
config = _ConfigParser()
config.read(file)
# strip down whatever we read to only what is legit
authdata = {x: config.get('authentication', x)
if config.has_option('authentication', x)
else None for x in ('user_id', 'token',
'client_secret', 'keyfile',
'keyfile_passphrase', 'password')}
except Exception, e:
print "Error while reading INI file %s: %s" % (file, e)
return authdata
class ServerError(Exception):
def __init__(self, name, code, message, data=None, error=None):
self.name = name
self.code = code
self.message = '' if message is None else message
self.data = data or error or ''
# data = JSON RPC 2.0, error = 1.1
def __str__(self):
return self.name + ': ' + str(self.code) + '. ' + self.message + \
'\n' + self.data
class _JSONObjectEncoder(_json.JSONEncoder):
def default(self, obj):
if isinstance(obj, set):
return list(obj)
if isinstance(obj, frozenset):
return list(obj)
return _json.JSONEncoder.default(self, obj)
class ModelComparison(object):
def __init__(self, url=None, timeout=30 * 60, user_id=None,
password=None, token=None, ignore_authrc=False,
trust_all_ssl_certificates=False):
if url is None:
raise ValueError('A url is required')
scheme, _, _, _, _, _ = _urlparse.urlparse(url)
if scheme not in _URL_SCHEME:
raise ValueError(url + " isn't a valid http url")
self.url = url
self.timeout = int(timeout)
self._headers = dict()
self.trust_all_ssl_certificates = trust_all_ssl_certificates
# token overrides user_id and password
if token is not None:
self._headers['AUTHORIZATION'] = token
elif user_id is not None and password is not None:
self._headers['AUTHORIZATION'] = _get_token(user_id, password)
elif 'KB_AUTH_TOKEN' in _os.environ:
self._headers['AUTHORIZATION'] = _os.environ.get('KB_AUTH_TOKEN')
elif not ignore_authrc:
authdata = _read_inifile()
if authdata is None:
authdata = _read_rcfile()
if authdata is not None:
if authdata.get('token') is not None:
self._headers['AUTHORIZATION'] = authdata['token']
elif(authdata.get('user_id') is not None
and authdata.get('password') is not None):
self._headers['AUTHORIZATION'] = _get_token(
authdata['user_id'], authdata['password'])
if self.timeout < 1:
raise ValueError('Timeout value must be at least 1 second')
def _call(self, method, params, json_rpc_context = None):
arg_hash = {'method': method,
'params': params,
'version': '1.1',
'id': str(_random.random())[2:]
}
if json_rpc_context:
arg_hash['context'] = json_rpc_context
body = _json.dumps(arg_hash, cls=_JSONObjectEncoder)
ret = _requests.post(self.url, data=body, headers=self._headers,
timeout=self.timeout,
verify=not self.trust_all_ssl_certificates)
if ret.status_code == _requests.codes.server_error:
json_header = None
if _CT in ret.headers:
json_header = ret.headers[_CT]
if _CT in ret.headers and ret.headers[_CT] == _AJ:
err = _json.loads(ret.text)
if 'error' in err:
raise ServerError(**err['error'])
else:
raise ServerError('Unknown', 0, ret.text)
else:
raise ServerError('Unknown', 0, ret.text)
if ret.status_code != _requests.codes.OK:
ret.raise_for_status()
ret.encoding = 'utf-8'
resp = _json.loads(ret.text)
if 'result' not in resp:
raise ServerError('Unknown', 0, 'An unknown server error occurred')
return resp['result']
def compare_models(self, params, json_rpc_context = None):
if json_rpc_context and type(json_rpc_context) is not dict:
raise ValueError('Method compare_models: argument json_rpc_context is not type dict as required.')
resp = self._call('ModelComparison.compare_models',
[params], json_rpc_context)
return resp[0]
| mdejongh/ModelComparison | lib/ModelComparison/ModelComparisonClient.py | Python | mit | 7,099 | 0.001127 |
# -*- coding: utf-8 -*-
#
# Copyright © 2013 Red Hat, Inc.
#
# This software is licensed to you under the GNU General Public
# License as published by the Free Software Foundation; either version
# 2 of the License (GPLv2) or (at your option) any later version.
# There is NO WARRANTY for this software, express or implied,
# including the implied warranties of MERCHANTABILITY,
# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
# have received a copy of GPLv2 along with this software; if not, see
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
from base import PulpServerTests
from pulp.server.db import connection
from pulp.server.db.migrate.models import MigrationModule
from pulp.plugins.types.database import TYPE_COLLECTION_PREFIX
ID = '_id'
LAST_UPDATED = '_last_updated'
MIGRATION = 'pulp.server.db.migrations.0005_unit_last_updated'
def test_collections(n=3):
names = []
for suffix in range(0, n):
name = TYPE_COLLECTION_PREFIX + str(suffix)
names.append(name)
return names
def test_units(n=10):
units = []
for unit_id in range(0, n):
unit = {ID: unit_id}
if unit_id % 2 == 0:
unit[LAST_UPDATED] = 1
units.append(unit)
return units
TEST_COLLECTIONS = test_collections()
TEST_UNITS = test_units()
class TestMigration_0005(PulpServerTests):
def setUp(self):
self.clean()
super(TestMigration_0005, self).setUp()
for collection in [connection.get_collection(n, True) for n in TEST_COLLECTIONS]:
for unit in TEST_UNITS:
collection.save(unit, safe=True)
def tearDown(self):
super(TestMigration_0005, self).tearDown()
self.clean()
def clean(self):
database = connection.get_database()
for name in [n for n in database.collection_names() if n in TEST_COLLECTIONS]:
database.drop_collection(name)
def test(self):
# migrate
module = MigrationModule(MIGRATION)._module
module.migrate()
# validation
for collection in [connection.get_collection(n) for n in TEST_COLLECTIONS]:
for unit in collection.find({}):
self.assertTrue(LAST_UPDATED in unit)
unit_id = unit[ID]
last_updated = unit[LAST_UPDATED]
if unit_id % 2 == 0:
self.assertEqual(last_updated, 1)
else:
self.assertTrue(isinstance(last_updated, float))
| beav/pulp | server/test/unit/test_migration_0005.py | Python | gpl-2.0 | 2,511 | 0.001195 |
# coding=utf-8
# Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for parametric_attention."""
import numpy as np
import tensorflow as tf
from multiple_user_representations.models import parametric_attention
class ParametricAttentionTest(tf.test.TestCase):
def test_parametric_attention_model_with_single_representation(self):
model = parametric_attention.SimpleParametricAttention(
output_dimension=2,
input_embedding_dimension=2,
vocab_size=10,
num_representations=1,
max_sequence_size=20)
input_batch = tf.convert_to_tensor(
np.random.randint(low=0, high=10, size=(10, 20)))
output = model(input_batch)
self.assertIsInstance(model, tf.keras.Model)
self.assertSequenceEqual(output.numpy().shape, [10, 1, 2])
def test_parametric_attention_model_with_multiple_representations(self):
model = parametric_attention.SimpleParametricAttention(
output_dimension=2,
input_embedding_dimension=2,
vocab_size=10,
num_representations=3,
max_sequence_size=20)
input_batch = tf.convert_to_tensor(
np.random.randint(low=0, high=10, size=(10, 20)))
output = model(input_batch)
self.assertIsInstance(model, tf.keras.Model)
self.assertSequenceEqual(output.numpy().shape, [10, 3, 2])
if __name__ == '__main__':
tf.test.main()
| google-research/google-research | multiple_user_representations/models/parametric_attention_test.py | Python | apache-2.0 | 1,915 | 0.001567 |
from maze_builder.sewer import MadLibs, Choice
from maze_builder.lost_text.text_decorations import fix_sentence
negative_status_sentence = MadLibs({
'{NEGATIVE_STATUS INTENSIFIED SENTENCE FIXED}': 1,
'{NEGATIVE_STATUS SENTENCE FIXED}': 1,
},
FIXED=fix_sentence,
SENTENCE={
'{}.': 30,
'{}!': 10,
'{} again?': 10,
'{} now.': 2,
'{} here.': 5,
'{} here!': 2,
'{}. Now I know what that means.': 1,
'{}: and not for the first time.': 1,
'{} -- and not for the first time.': 1,
'{}? Yes, always.': 1,
'I feel {}.': 10,
'I feel so {}.': 5,
'I feel so {}!': 5,
'I\'m {}.': 10,
'I\'m so {}.': 5,
'Will I always be so {}?': 1,
'Why am I so {}?': 1,
'No one knows how {} I am.': 1,
'Has anyone ever been so {} before?': 1,
'Has anyone ever been so {}?': 1,
'Has anyone ever felt so {}?': 1,
'I never want to feel this {} again.': 1,
'I hope I\'ll never be so {} again.': 1,
'I can\'t stand being so {}.': 1,
'I\'ve never been so {}.': 1,
'I\'ve never been so {} before.': 1,
'Before this trip, I\'d never been so {}.': 1,
'At home, no one is ever so {}.': 1,
'So {} a person can be.': 1,
'So {} a person can feel.': 1,
'We weren\'t meant to feel so {}.': 1,
'I never knew what it was like to be so {}.': 1,
'No one has ever been so {}.': 1,
'I could write a book about being so {}.': 1,
'Even in my dreams, I\'m {}.': 1,
'I\'m as {} as I\'ve ever been.': 1,
'Why does God allow us to be so {}?': 1,
'Would I have come this way, if I\'d known I\'d be so {}?': 1,
},
INTENSIFIED={
'awfully {}': 1,
'amazingly {}': 1,
'cursedly {}': 1,
'critically {}': 1,
'deathly {}': 1,
'meagerly {}': 0.2,
'super-{}': 1,
'devastatingly {}': 1,
'terribly {}': 1,
'dreadfully {}': 1,
'wickedly {}': 1,
'disgracefully {}': 1,
'completely {}': 1,
'reprehensibly {}': 1,
'unforgivably {}': 1,
'unpleasantly {}': 1,
'wretchedly {}': 1,
},
NEGATIVE_STATUS={ # Used as '{}' or 'I'm so {}...'
'hungry': 2,
'cold': 2,
'tired': 5,
'exhausted': 1,
'defeated': 1,
'worn out': 1,
'ravenous': 1,
'faint': 1,
'empty': 1,
'hollow': 1,
'insatiable': 1,
'famished': 1,
'unsatisfied': 1,
'beat': 1,
'annoyed': 1,
'bored': 2,
'distressed': 1,
'drained': 1,
'exasperated': 1,
'fatigued': 1,
'sleepy': 1,
'collapsing': 1,
'jaded': 1,
'overtaxed': 1,
'spent': 1,
'wasted': 1,
'worn': 1,
'burned out': 1,
'done for': 1,
'lost': 20,
'desolate': 1,
'lonesome': 1,
'alone': 1,
'spiritless': 1,
'sick and tired': 1,
'sick': 1,
'unenthusiastic': 1,
'unenergetic': 1,
'adrift': 1,
'disoriented': 5,
'astray': 1,
'off-course': 5,
'perplexed': 2,
'bewildered': 2,
'confused': 5,
'contrite': 1,
'unsettled': 1,
'puzzled': 5,
'ailing': 1,
'ill': 1,
'debilitated': 1,
'frail': 1,
'impaired': 1,
'nauseated': 2,
'bedridden': 1,
'not so hot': 1,
'under the weather': 1,
'run down': 1,
'unhealthy': 1,
'unwell': 1,
'weak': 1,
'laid-up': 1,
'rotten': 1,
'anemic': 1,
'feeble': 1,
'confused': 10,
'fragile': 1,
'hesitant': 2,
'powerless': 1,
'uncertain': 5,
'shaky': 1,
'sickly': 1,
'sluggish': 1,
'slow': 1,
'unsteady': 1,
'weakened': 1,
'wobbly': 1,
'puny': 1,
'out of gas': 1,
'irresolute': 1,
'spent': 1,
'infirm': 1,
'chilled': 1,
'frozen': 1,
'frigid': 1,
'raw': 1,
'numbed': 1,
'benumbed': 1,
'thirsty': 1,
'parched': 1,
'injured': 5,
'afraid': 5,
'terrified': 1,
'anxious': 1,
'apprehensive': 1,
'frightened': 1,
'nervous': 1,
'scared': 1,
'cowardly': 1,
'daunted': 1,
'discouraged': 1,
'disheartened': 1,
'dismayed': 1,
'distressed': 1,
'horrified': 1,
'panic-stricken': 1,
'petrified': 1,
'scared stiff': 1,
'scared to death': 1,
'terror-stricken': 1,
'humbled': 1,
'dead': 1,
'naked': 1,
'wild': 1,
'uncivilized': 1,
'scorched': 1,
'withered': 1,
'sunburned': 1,
'windburned': 1,
'frostbitten': 1,
'dehydrated': 1,
'shriveled': 1,
'dried up': 1,
'dried out': 1,
'smelly': 1,
'stinky': 1,
'noxious': 1,
'putrid': 1,
'revolting': 1,
'grody': 1,
'gross': 1,
'icky': 1,
}
)
| kcsaff/maze-builder | maze_builder/lost_text/negative_status.py | Python | mit | 5,360 | 0 |
# -*- encoding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# ThinkOpen Solutions Brasil
# Copyright (C) Thinkopen Solutions <http://www.tkobr.com>.
#
# 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/>.
#
##############################################################################
{
'name': 'Partner multiple phones',
'version': '0.008',
'category': 'Customizations',
'sequence': 16,
'complexity': 'normal',
'description': '''== Partner multiple phones module ==\n\n
This modules add a tab to manage multiple phones for a partner.\n
The phones are searchable from tree list view like in standard module.\n
This module don't break phone functionality because it keeps the phone char field in partner form.\n
''',
'author': 'ThinkOpen Solutions Brasil',
'website': 'http://www.tkobr.com',
'images': ['images/oerp61.jpeg',
],
'depends': [
'tko_contacts',
],
'data': [
'security/ir.model.access.csv',
'views/tko_partner_phones_view.xml',
'views/res_partner_view.xml',
],
'init': [],
'demo': [],
'update': [],
'test': [], # YAML files with tests
'installable': True,
'application': False,
# If it's True, the modules will be auto-installed when all dependencies
# are installed
'auto_install': False,
'certificate': '',
}
| thinkopensolutions/tkobr-addons | tko_partner_multiple_phones/__manifest__.py | Python | agpl-3.0 | 2,154 | 0.000464 |
#############################################################################
##
## Copyright (C) 2016 The Qt Company Ltd.
## Contact: https://www.qt.io/licensing/
##
## This file is part of the test suite of PySide2.
##
## $QT_BEGIN_LICENSE:GPL-EXCEPT$
## Commercial License Usage
## Licensees holding valid commercial Qt licenses may use this file in
## accordance with the commercial license agreement provided with the
## Software or, alternatively, in accordance with the terms contained in
## a written agreement between you and The Qt Company. For licensing terms
## and conditions see https://www.qt.io/terms-conditions. For further
## information use the contact form at https://www.qt.io/contact-us.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 3 as published by the Free Software
## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
## included in the packaging of this file. Please review the following
## information to ensure the GNU General Public License requirements will
## be met: https://www.gnu.org/licenses/gpl-3.0.html.
##
## $QT_END_LICENSE$
##
#############################################################################
import unittest
import colorsys
import PySide2
from PySide2.QtCore import Qt
from PySide2.QtGui import QColor
class QColorGetTest(unittest.TestCase):
def setUp(self):
self.color = QColor(20, 40, 60, 80)
def testGetRgb(self):
self.assertEqual(self.color.getRgb(), (20, 40, 60, 80))
def testGetHslF(self):
hls = colorsys.rgb_to_hls(20.0/255, 40.0/255, 60.0/255)
hsla = hls[0], hls[2], hls[1], self.color.alphaF()
for x, y in zip(self.color.getHslF(), hsla): # Due to rounding problems
self.assertTrue(x - y < 1/100000.0)
def testGetHsv(self):
hsv = colorsys.rgb_to_hsv(20.0/255, 40.0/255, 60.0/255)
hsva = int(hsv[0]*360.0), int(hsv[1]*255), int(hsv[2]*256), self.color.alpha()
self.assertEqual(self.color.getHsv(), hsva)
def testGetCmyk(self): # not supported by colorsys
self.assertEqual(self.color.getCmyk(), (170, 85, 0, 195, 80))
def testGetCmykF(self): # not supported by colorsys
for x, y in zip(self.color.getCmykF(), (170/255.0, 85/255.0, 0, 195/255.0, 80/255.0)):
self.assertTrue(x - y < 1/10000.0)
class QColorQRgbConstructor(unittest.TestCase):
'''QColor(QRgb) constructor'''
# Affected by bug #170 - QColor(QVariant) coming before QColor(uint)
# in overload sorting
def testBasic(self):
'''QColor(QRgb)'''
color = QColor(255, 0, 0)
#QRgb format #AARRGGBB
rgb = 0x00FF0000
self.assertEqual(QColor(rgb), color)
class QColorEqualGlobalColor(unittest.TestCase):
def testEqualGlobalColor(self):
'''QColor == Qt::GlobalColor'''
self.assertEqual(QColor(255, 0, 0), Qt.red)
class QColorCopy(unittest.TestCase):
def testDeepCopy(self):
'''QColor deepcopy'''
from copy import deepcopy
original = QColor(0, 0, 255)
copy = deepcopy([original])[0]
self.assertTrue(original is not copy)
self.assertEqual(original, copy)
del original
self.assertEqual(copy, QColor(0, 0, 255))
def testEmptyCopy(self):
from copy import deepcopy
original = QColor()
copy = deepcopy([original])[0]
self.assertTrue(original is not copy)
self.assertEqual(original, copy)
del original
self.assertEqual(copy, QColor())
class QColorRepr(unittest.TestCase):
def testReprFunction(self):
c = QColor(100, 120, 200)
c2 = eval(c.__repr__())
self.assertEqual(c, c2)
def testStrFunction(self):
c = QColor('red')
c2 = eval(c.__str__())
self.assertEqual(c, c2)
if __name__ == '__main__':
unittest.main()
| qtproject/pyside-pyside | tests/QtGui/qcolor_test.py | Python | lgpl-2.1 | 3,949 | 0.006584 |
from os import walk
files = []
for (dirpath, dirnames, filenames) in walk('./data/'):
files.extend(filenames)
break
data = []
OFratio = None
for file in files:
t = []
with open('./data/' + file) as f:
for i, line in enumerate(f):
if i in [15, 24, 25, 29, 31, 34, 39]:
t.append(line.split())
OFratio = t[0][2]
Pc = t[1][1]
Tc = t[2][1]
Te = t[2][4]
Pe = t[1][4]
MW = t[5][4]
gamma = t[4][4]
Mach = t[6][5]
Cpc = t[3][3]
Cpe = t[3][6]
data.append([Pc, Tc, Te, Pe, MW, gamma, Mach, Cpc, Cpe])
if len(data) < 15:
print('[WRN] Less than 15 keys!')
block = ''.join(['MixtureRatioData\n{\n OFratio =', OFratio,
'\n PressureData\n {\n',
''.join([' key = {}, {}, {}, {}, {}, {}, {}, {}, {}\n'.format(*line) for line in data]),
' }\n}'])
with open('./data/results.txt', 'a') as f:
f.write(block)
| ferram4/ProcEngines | GameData/ProcEngines/PropellantMixtures/config_parser.py | Python | mit | 928 | 0.003233 |
# -*- coding: utf-8 -*-
# Style_Check:Python_Fragment (meaning no pyflakes check)
#
# GNAT build configuration file
import sys
import os
import time
import re
sys.path.append('.')
import ada_pygments
import latex_elements
# Some configuration values for the various documentation handled by
# this conf.py
DOCS = {
'gnat_rm': {
'title': u'GNAT Reference Manual'},
'gnat_ugn': {
'title': u'GNAT User\'s Guide for Native Platforms'}}
# Then retrieve the source directory
root_source_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
gnatvsn_spec = os.path.join(root_source_dir, '..', 'gnatvsn.ads')
basever = os.path.join(root_source_dir, '..', '..', 'BASE-VER')
texi_fsf = True # Set to False when FSF doc is switched to sphinx by default
with open(gnatvsn_spec, 'rb') as fd:
gnatvsn_content = fd.read()
def get_copyright():
return u'2008-%s, Free Software Foundation' % time.strftime('%Y')
def get_gnat_version():
m = re.search(r'Gnat_Static_Version_String : ' +
r'constant String := "([^\(\)]+)\(.*\)?";',
gnatvsn_content)
if m:
return m.group(1).strip()
else:
if texi_fsf and os.path.exists(basever):
return ''
try:
with open(basever, 'rb') as fd:
return fd.read()
except:
pass
print 'cannot find GNAT version in gnatvsn.ads or in ' + basever
sys.exit(1)
def get_gnat_build_type():
m = re.search(r'Build_Type : constant Gnat_Build_Type := (.+);',
gnatvsn_content)
if m:
return {'Gnatpro': 'PRO',
'FSF': 'FSF',
'GPL': 'GPL'}[m.group(1).strip()]
else:
print 'cannot compute GNAT build type'
sys.exit(1)
# First retrieve the name of the documentation we are building
doc_name = os.environ.get('DOC_NAME', None)
if doc_name is None:
print 'DOC_NAME environment variable should be set'
sys.exit(1)
if doc_name not in DOCS:
print '%s is not a valid documentation name' % doc_name
sys.exit(1)
# Exclude sources that are not part of the current documentation
exclude_patterns = []
for d in os.listdir(root_source_dir):
if d not in ('share', doc_name, doc_name + '.rst'):
exclude_patterns.append(d)
print 'ignoring %s' % d
if doc_name == 'gnat_rm':
exclude_patterns.append('share/gnat_project_manager.rst')
print 'ignoring share/gnat_project_manager.rst'
extensions = []
templates_path = ['_templates']
source_suffix = '.rst'
master_doc = doc_name
# General information about the project.
project = DOCS[doc_name]['title']
copyright = get_copyright()
version = get_gnat_version()
release = get_gnat_version()
pygments_style = 'sphinx'
tags.add(get_gnat_build_type())
html_theme = 'sphinxdoc'
if os.path.isfile('adacore_transparent.png'):
html_logo = 'adacore_transparent.png'
if os.path.isfile('favicon.ico'):
html_favicon = 'favicon.ico'
html_static_path = ['_static']
latex_additional_files = ['gnat.sty']
copyright_macros = {
'date': time.strftime("%b %d, %Y"),
'edition': 'GNAT %s Edition' % 'Pro' if get_gnat_build_type() == 'PRO'
else 'GPL',
'name': u'GNU Ada',
'tool': u'GNAT',
'version': version}
latex_elements = {
'preamble': '\\usepackage{gnat}\n' +
latex_elements.TOC_DEPTH +
latex_elements.PAGE_BLANK +
latex_elements.TOC_CMD +
latex_elements.LATEX_HYPHEN +
latex_elements.doc_settings(DOCS[doc_name]['title'],
get_gnat_version()),
'tableofcontents': latex_elements.TOC % copyright_macros}
latex_documents = [
(master_doc, '%s.tex' % doc_name, project, u'AdaCore', 'manual')]
texinfo_documents = [
(master_doc, doc_name, project,
u'AdaCore', doc_name, doc_name, '')]
def setup(app):
app.add_lexer('ada', ada_pygments.AdaLexer())
app.add_lexer('gpr', ada_pygments.GNATProjectLexer())
| Gurgel100/gcc | gcc/ada/doc/share/conf.py | Python | gpl-2.0 | 3,966 | 0.000756 |
from django.db import models
from fluxbb import FLUXBB_PREFIX
class SearchWord(models.Model):
"""
FluxBB Search Word
Fields on this model match exactly with those defined by fluxbb, see the
[fluxbb dbstructure](http://fluxbb.org/docs/v1.5/dbstructure#users).
"""
id = models.AutoField(primary_key=True)
word = models.CharField(max_length=20, default="")
class Meta:
app_label = 'fluxbb'
db_table = FLUXBB_PREFIX + 'search_words'
| kalhartt/django-fluxbb | fluxbb/models/search_word.py | Python | gpl-2.0 | 481 | 0 |
#!/usr/bin/python
import smbus
import time
'''
retrieve data from wii ir camera.
x = 0-1023
y = 0-720
size = 1-15?
top right of scene = [0,0]
'''
def getBlob(n,list): # return x,y,size for blob n (0-3) from list
if len(list)<13:
return []
x = list[1+(n*3)]
y = list[2+(n*3)]
s = list[3+(n*3)]
x += (s&0x30)<<4
y += (s&0xC0)<<2
s = s&0x0F
return [x,y,s]
wiiAddr = 0x58
i2c = smbus.SMBus(1)
i2c.write_byte_data(wiiAddr, 0x30,0x01)
time.sleep(0.05)
i2c.write_byte_data(wiiAddr, 0x30,0x08)
time.sleep(0.05)
i2c.write_byte_data(wiiAddr, 0x06,0x90)
time.sleep(0.05)
i2c.write_byte_data(wiiAddr, 0x08,0xC0)
time.sleep(0.05)
i2c.write_byte_data(wiiAddr, 0x1A,0x40)
time.sleep(0.05)
i2c.write_byte_data(wiiAddr, 0x33,0x33)
time.sleep(0.05)
while 1:
data = i2c.read_i2c_block_data(wiiAddr, 0x36, 16)
print len(data), "\t", getBlob(0,data), "\t", getBlob(1,data), "\t", getBlob(2,data), "\t", getBlob(3,data)
time.sleep(0.5)
| roving99/robot_pi | 0mq/wii_ir_test.py | Python | gpl-2.0 | 966 | 0.030021 |
# Copyright (C) 2008 Canonical Ltd
#
# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from __future__ import absolute_import
import collections
from cStringIO import StringIO
from bzrlib import (
debug,
errors,
)
from bzrlib.trace import mutter
class MessageHandler(object):
"""Base class for handling messages received via the smart protocol.
As parts of a message are received, the corresponding PART_received method
will be called.
"""
def __init__(self):
self.headers = None
def headers_received(self, headers):
"""Called when message headers are received.
This default implementation just stores them in self.headers.
"""
self.headers = headers
def byte_part_received(self, byte):
"""Called when a 'byte' part is received.
Note that a 'byte' part is a message part consisting of exactly one
byte.
"""
raise NotImplementedError(self.byte_received)
def bytes_part_received(self, bytes):
"""Called when a 'bytes' part is received.
A 'bytes' message part can contain any number of bytes. It should not
be confused with a 'byte' part, which is always a single byte.
"""
raise NotImplementedError(self.bytes_received)
def structure_part_received(self, structure):
"""Called when a 'structure' part is received.
:param structure: some structured data, which will be some combination
of list, dict, int, and str objects.
"""
raise NotImplementedError(self.bytes_received)
def protocol_error(self, exception):
"""Called when there is a protocol decoding error.
The default implementation just re-raises the exception.
"""
raise
def end_received(self):
"""Called when the end of the message is received."""
# No-op by default.
pass
class ConventionalRequestHandler(MessageHandler):
"""A message handler for "conventional" requests.
"Conventional" is used in the sense described in
doc/developers/network-protocol.txt: a simple message with arguments and an
optional body.
Possible states:
* args: expecting args
* body: expecting body (terminated by receiving a post-body status)
* error: expecting post-body error
* end: expecting end of message
* nothing: finished
"""
def __init__(self, request_handler, responder):
MessageHandler.__init__(self)
self.request_handler = request_handler
self.responder = responder
self.expecting = 'args'
self._should_finish_body = False
self._response_sent = False
def protocol_error(self, exception):
if self.responder.response_sent:
# We can only send one response to a request, no matter how many
# errors happen while processing it.
return
self.responder.send_error(exception)
def byte_part_received(self, byte):
if self.expecting == 'body':
if byte == 'S':
# Success. Nothing more to come except the end of message.
self.expecting = 'end'
elif byte == 'E':
# Error. Expect an error structure.
self.expecting = 'error'
else:
raise errors.SmartProtocolError(
'Non-success status byte in request body: %r' % (byte,))
else:
raise errors.SmartProtocolError(
'Unexpected message part: byte(%r)' % (byte,))
def structure_part_received(self, structure):
if self.expecting == 'args':
self._args_received(structure)
elif self.expecting == 'error':
self._error_received(structure)
else:
raise errors.SmartProtocolError(
'Unexpected message part: structure(%r)' % (structure,))
def _args_received(self, args):
self.expecting = 'body'
self.request_handler.args_received(args)
if self.request_handler.finished_reading:
self._response_sent = True
self.responder.send_response(self.request_handler.response)
self.expecting = 'end'
def _error_received(self, error_args):
self.expecting = 'end'
self.request_handler.post_body_error_received(error_args)
def bytes_part_received(self, bytes):
if self.expecting == 'body':
self._should_finish_body = True
self.request_handler.accept_body(bytes)
else:
raise errors.SmartProtocolError(
'Unexpected message part: bytes(%r)' % (bytes,))
def end_received(self):
if self.expecting not in ['body', 'end']:
raise errors.SmartProtocolError(
'End of message received prematurely (while expecting %s)'
% (self.expecting,))
self.expecting = 'nothing'
self.request_handler.end_received()
if not self.request_handler.finished_reading:
raise errors.SmartProtocolError(
"Complete conventional request was received, but request "
"handler has not finished reading.")
if not self._response_sent:
self.responder.send_response(self.request_handler.response)
class ResponseHandler(object):
"""Abstract base class for an object that handles a smart response."""
def read_response_tuple(self, expect_body=False):
"""Reads and returns the response tuple for the current request.
:keyword expect_body: a boolean indicating if a body is expected in the
response. Some protocol versions needs this information to know
when a response is finished. If False, read_body_bytes should
*not* be called afterwards. Defaults to False.
:returns: tuple of response arguments.
"""
raise NotImplementedError(self.read_response_tuple)
def read_body_bytes(self, count=-1):
"""Read and return some bytes from the body.
:param count: if specified, read up to this many bytes. By default,
reads the entire body.
:returns: str of bytes from the response body.
"""
raise NotImplementedError(self.read_body_bytes)
def read_streamed_body(self):
"""Returns an iterable that reads and returns a series of body chunks.
"""
raise NotImplementedError(self.read_streamed_body)
def cancel_read_body(self):
"""Stop expecting a body for this response.
If expect_body was passed to read_response_tuple, this cancels that
expectation (and thus finishes reading the response, allowing a new
request to be issued). This is useful if a response turns out to be an
error rather than a normal result with a body.
"""
raise NotImplementedError(self.cancel_read_body)
class ConventionalResponseHandler(MessageHandler, ResponseHandler):
def __init__(self):
MessageHandler.__init__(self)
self.status = None
self.args = None
self._bytes_parts = collections.deque()
self._body_started = False
self._body_stream_status = None
self._body = None
self._body_error_args = None
self.finished_reading = False
def setProtoAndMediumRequest(self, protocol_decoder, medium_request):
self._protocol_decoder = protocol_decoder
self._medium_request = medium_request
def byte_part_received(self, byte):
if byte not in ['E', 'S']:
raise errors.SmartProtocolError(
'Unknown response status: %r' % (byte,))
if self._body_started:
if self._body_stream_status is not None:
raise errors.SmartProtocolError(
'Unexpected byte part received: %r' % (byte,))
self._body_stream_status = byte
else:
if self.status is not None:
raise errors.SmartProtocolError(
'Unexpected byte part received: %r' % (byte,))
self.status = byte
def bytes_part_received(self, bytes):
self._body_started = True
self._bytes_parts.append(bytes)
def structure_part_received(self, structure):
if type(structure) is not tuple:
raise errors.SmartProtocolError(
'Args structure is not a sequence: %r' % (structure,))
if not self._body_started:
if self.args is not None:
raise errors.SmartProtocolError(
'Unexpected structure received: %r (already got %r)'
% (structure, self.args))
self.args = structure
else:
if self._body_stream_status != 'E':
raise errors.SmartProtocolError(
'Unexpected structure received after body: %r'
% (structure,))
self._body_error_args = structure
def _wait_for_response_args(self):
while self.args is None and not self.finished_reading:
self._read_more()
def _wait_for_response_end(self):
while not self.finished_reading:
self._read_more()
def _read_more(self):
next_read_size = self._protocol_decoder.next_read_size()
if next_read_size == 0:
# a complete request has been read.
self.finished_reading = True
self._medium_request.finished_reading()
return
bytes = self._medium_request.read_bytes(next_read_size)
if bytes == '':
# end of file encountered reading from server
if 'hpss' in debug.debug_flags:
mutter(
'decoder state: buf[:10]=%r, state_accept=%s',
self._protocol_decoder._get_in_buffer()[:10],
self._protocol_decoder.state_accept.__name__)
raise errors.ConnectionReset(
"Unexpected end of message. "
"Please check connectivity and permissions, and report a bug "
"if problems persist.")
self._protocol_decoder.accept_bytes(bytes)
def protocol_error(self, exception):
# Whatever the error is, we're done with this request.
self.finished_reading = True
self._medium_request.finished_reading()
raise
def read_response_tuple(self, expect_body=False):
"""Read a response tuple from the wire."""
self._wait_for_response_args()
if not expect_body:
self._wait_for_response_end()
if 'hpss' in debug.debug_flags:
mutter(' result: %r', self.args)
if self.status == 'E':
self._wait_for_response_end()
_raise_smart_server_error(self.args)
return tuple(self.args)
def read_body_bytes(self, count=-1):
"""Read bytes from the body, decoding into a byte stream.
We read all bytes at once to ensure we've checked the trailer for
errors, and then feed the buffer back as read_body_bytes is called.
Like the builtin file.read in Python, a count of -1 (the default) means
read the entire body.
"""
# TODO: we don't necessarily need to buffer the full request if count
# != -1. (2008/04/30, Andrew Bennetts)
if self._body is None:
self._wait_for_response_end()
body_bytes = ''.join(self._bytes_parts)
if 'hpss' in debug.debug_flags:
mutter(' %d body bytes read', len(body_bytes))
self._body = StringIO(body_bytes)
self._bytes_parts = None
return self._body.read(count)
def read_streamed_body(self):
while not self.finished_reading:
while self._bytes_parts:
bytes_part = self._bytes_parts.popleft()
if 'hpssdetail' in debug.debug_flags:
mutter(' %d byte part read', len(bytes_part))
yield bytes_part
self._read_more()
if self._body_stream_status == 'E':
_raise_smart_server_error(self._body_error_args)
def cancel_read_body(self):
self._wait_for_response_end()
def _raise_smart_server_error(error_tuple):
"""Raise exception based on tuple received from smart server
Specific error translation is handled by bzrlib.remote._translate_error
"""
if error_tuple[0] == 'UnknownMethod':
raise errors.UnknownSmartMethod(error_tuple[1])
raise errors.ErrorFromSmartServer(error_tuple)
| Distrotech/bzr | bzrlib/smart/message.py | Python | gpl-2.0 | 13,276 | 0 |
# 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 Any, Callable, Dict, Generic, Optional, TypeVar, Union
import warnings
from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest
from azure.mgmt.core.exceptions import ARMErrorFormat
from ... import models as _models
T = TypeVar('T')
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
class ReferenceDataSetsOperations:
"""ReferenceDataSetsOperations async operations.
You should not instantiate this class directly. Instead, you should create a Client instance that
instantiates it for you and attaches it as an attribute.
:ivar models: Alias to model classes used in this operation group.
:type models: ~azure.mgmt.timeseriesinsights.models
:param client: Client for service requests.
:param config: Configuration of service client.
:param serializer: An object model serializer.
:param deserializer: An object model deserializer.
"""
models = _models
def __init__(self, client, config, serializer, deserializer) -> None:
self._client = client
self._serialize = serializer
self._deserialize = deserializer
self._config = config
async def create_or_update(
self,
resource_group_name: str,
environment_name: str,
reference_data_set_name: str,
parameters: "_models.ReferenceDataSetCreateOrUpdateParameters",
**kwargs
) -> "_models.ReferenceDataSetResource":
"""Create or update a reference data set in the specified environment.
:param resource_group_name: Name of an Azure Resource group.
:type resource_group_name: str
:param environment_name: The name of the Time Series Insights environment associated with the
specified resource group.
:type environment_name: str
:param reference_data_set_name: Name of the reference data set.
:type reference_data_set_name: str
:param parameters: Parameters for creating a reference data set.
:type parameters: ~azure.mgmt.timeseriesinsights.models.ReferenceDataSetCreateOrUpdateParameters
:keyword callable cls: A custom type or function that will be passed the direct response
:return: ReferenceDataSetResource, or the result of cls(response)
:rtype: ~azure.mgmt.timeseriesinsights.models.ReferenceDataSetResource
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ReferenceDataSetResource"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-05-15"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.create_or_update.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'environmentName': self._serialize.url("environment_name", environment_name, 'str'),
'referenceDataSetName': self._serialize.url("reference_data_set_name", reference_data_set_name, 'str', max_length=63, min_length=3, pattern=r'^[A-Za-z0-9]'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(parameters, 'ReferenceDataSetCreateOrUpdateParameters')
body_content_kwargs['content'] = body_content
request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200, 201]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
if response.status_code == 200:
deserialized = self._deserialize('ReferenceDataSetResource', pipeline_response)
if response.status_code == 201:
deserialized = self._deserialize('ReferenceDataSetResource', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
create_or_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.TimeSeriesInsights/environments/{environmentName}/referenceDataSets/{referenceDataSetName}'} # type: ignore
async def get(
self,
resource_group_name: str,
environment_name: str,
reference_data_set_name: str,
**kwargs
) -> "_models.ReferenceDataSetResource":
"""Gets the reference data set with the specified name in the specified environment.
:param resource_group_name: Name of an Azure Resource group.
:type resource_group_name: str
:param environment_name: The name of the Time Series Insights environment associated with the
specified resource group.
:type environment_name: str
:param reference_data_set_name: The name of the Time Series Insights reference data set
associated with the specified environment.
:type reference_data_set_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: ReferenceDataSetResource, or the result of cls(response)
:rtype: ~azure.mgmt.timeseriesinsights.models.ReferenceDataSetResource
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ReferenceDataSetResource"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-05-15"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'environmentName': self._serialize.url("environment_name", environment_name, 'str'),
'referenceDataSetName': self._serialize.url("reference_data_set_name", reference_data_set_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('ReferenceDataSetResource', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.TimeSeriesInsights/environments/{environmentName}/referenceDataSets/{referenceDataSetName}'} # type: ignore
async def update(
self,
resource_group_name: str,
environment_name: str,
reference_data_set_name: str,
reference_data_set_update_parameters: "_models.ReferenceDataSetUpdateParameters",
**kwargs
) -> "_models.ReferenceDataSetResource":
"""Updates the reference data set with the specified name in the specified subscription, resource
group, and environment.
:param resource_group_name: Name of an Azure Resource group.
:type resource_group_name: str
:param environment_name: The name of the Time Series Insights environment associated with the
specified resource group.
:type environment_name: str
:param reference_data_set_name: The name of the Time Series Insights reference data set
associated with the specified environment.
:type reference_data_set_name: str
:param reference_data_set_update_parameters: Request object that contains the updated
information for the reference data set.
:type reference_data_set_update_parameters: ~azure.mgmt.timeseriesinsights.models.ReferenceDataSetUpdateParameters
:keyword callable cls: A custom type or function that will be passed the direct response
:return: ReferenceDataSetResource, or the result of cls(response)
:rtype: ~azure.mgmt.timeseriesinsights.models.ReferenceDataSetResource
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ReferenceDataSetResource"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-05-15"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.update.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'environmentName': self._serialize.url("environment_name", environment_name, 'str'),
'referenceDataSetName': self._serialize.url("reference_data_set_name", reference_data_set_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(reference_data_set_update_parameters, 'ReferenceDataSetUpdateParameters')
body_content_kwargs['content'] = body_content
request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('ReferenceDataSetResource', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.TimeSeriesInsights/environments/{environmentName}/referenceDataSets/{referenceDataSetName}'} # type: ignore
async def delete(
self,
resource_group_name: str,
environment_name: str,
reference_data_set_name: str,
**kwargs
) -> None:
"""Deletes the reference data set with the specified name in the specified subscription, resource
group, and environment.
:param resource_group_name: Name of an Azure Resource group.
:type resource_group_name: str
:param environment_name: The name of the Time Series Insights environment associated with the
specified resource group.
:type environment_name: str
:param reference_data_set_name: The name of the Time Series Insights reference data set
associated with the specified environment.
:type reference_data_set_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: None, or the result of cls(response)
:rtype: None
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType[None]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-05-15"
accept = "application/json"
# Construct URL
url = self.delete.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'environmentName': self._serialize.url("environment_name", environment_name, 'str'),
'referenceDataSetName': self._serialize.url("reference_data_set_name", reference_data_set_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.delete(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200, 204]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
if cls:
return cls(pipeline_response, None, {})
delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.TimeSeriesInsights/environments/{environmentName}/referenceDataSets/{referenceDataSetName}'} # type: ignore
async def list_by_environment(
self,
resource_group_name: str,
environment_name: str,
**kwargs
) -> "_models.ReferenceDataSetListResponse":
"""Lists all the available reference data sets associated with the subscription and within the
specified resource group and environment.
:param resource_group_name: Name of an Azure Resource group.
:type resource_group_name: str
:param environment_name: The name of the Time Series Insights environment associated with the
specified resource group.
:type environment_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: ReferenceDataSetListResponse, or the result of cls(response)
:rtype: ~azure.mgmt.timeseriesinsights.models.ReferenceDataSetListResponse
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ReferenceDataSetListResponse"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-05-15"
accept = "application/json"
# Construct URL
url = self.list_by_environment.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'environmentName': self._serialize.url("environment_name", environment_name, 'str'),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('ReferenceDataSetListResponse', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
list_by_environment.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.TimeSeriesInsights/environments/{environmentName}/referenceDataSets'} # type: ignore
| Azure/azure-sdk-for-python | sdk/timeseriesinsights/azure-mgmt-timeseriesinsights/azure/mgmt/timeseriesinsights/aio/operations/_reference_data_sets_operations.py | Python | mit | 19,516 | 0.00497 |
from setuptools import setup, find_packages
import os
description = "Make sure all source files have your standard licensing stub "\
"at the top."
long_description = ""
setup(name='plicense',
version='0.2.1',
description=description,
long_description=long_description,
classifiers=[],
keywords='license',
author='Dustin Oprea',
author_email='myselfasunder@gmail.com',
url='https://github.com/dsoprea/LicensePrepend',
license='GPL 2',
packages=find_packages(exclude=[]),
include_package_data=True,
zip_safe=True,
install_requires=[
'nose'
],
scripts=['scripts/plicense'],
)
| dsoprea/LicensePrepend | setup.py | Python | gpl-2.0 | 692 | 0.001445 |
# coding: utf-8
# pylint: disable = invalid-name, C0111, C0301
# pylint: disable = R0912, R0913, R0914, W0105, W0201, W0212
"""Wrapper c_api of LightGBM"""
from __future__ import absolute_import
import ctypes
import os
from tempfile import NamedTemporaryFile
import numpy as np
import scipy.sparse
from .compat import (DataFrame, Series, integer_types, json,
json_default_with_numpy, numeric_types, range_,
string_type)
from .libpath import find_lib_path
def _load_lib():
"""Load LightGBM Library."""
lib_path = find_lib_path()
if len(lib_path) == 0:
raise Exception("cannot find LightGBM library")
lib = ctypes.cdll.LoadLibrary(lib_path[0])
lib.LGBM_GetLastError.restype = ctypes.c_char_p
return lib
_LIB = _load_lib()
class LightGBMError(Exception):
"""Error throwed by LightGBM"""
pass
def _safe_call(ret):
"""Check the return value of C API call
Parameters
----------
ret : int
return value from API calls
"""
if ret != 0:
raise LightGBMError(_LIB.LGBM_GetLastError())
def is_numeric(obj):
"""Check is a number or not, include numpy number etc."""
try:
float(obj)
return True
except (TypeError, ValueError):
# TypeError: obj is not a string or a number
# ValueError: invalid literal
return False
def is_numpy_1d_array(data):
"""Check is 1d numpy array"""
return isinstance(data, np.ndarray) and len(data.shape) == 1
def is_1d_list(data):
"""Check is 1d list"""
return isinstance(data, list) and \
(not data or isinstance(data[0], numeric_types))
def list_to_1d_numpy(data, dtype=np.float32, name='list'):
"""convert to 1d numpy array"""
if is_numpy_1d_array(data):
if data.dtype == dtype:
return data
else:
return data.astype(dtype=dtype, copy=False)
elif is_1d_list(data):
return np.array(data, dtype=dtype, copy=False)
elif isinstance(data, Series):
return data.values.astype(dtype)
else:
raise TypeError("Wrong type({}) for {}, should be list or numpy array".format(type(data).__name__, name))
def cfloat32_array_to_numpy(cptr, length):
"""Convert a ctypes float pointer array to a numpy array.
"""
if isinstance(cptr, ctypes.POINTER(ctypes.c_float)):
return np.fromiter(cptr, dtype=np.float32, count=length)
else:
raise RuntimeError('Expected float pointer')
def cfloat64_array_to_numpy(cptr, length):
"""Convert a ctypes double pointer array to a numpy array.
"""
if isinstance(cptr, ctypes.POINTER(ctypes.c_double)):
return np.fromiter(cptr, dtype=np.float64, count=length)
else:
raise RuntimeError('Expected double pointer')
def cint32_array_to_numpy(cptr, length):
"""Convert a ctypes float pointer array to a numpy array.
"""
if isinstance(cptr, ctypes.POINTER(ctypes.c_int32)):
return np.fromiter(cptr, dtype=np.int32, count=length)
else:
raise RuntimeError('Expected int pointer')
def c_str(string):
"""Convert a python string to cstring."""
return ctypes.c_char_p(string.encode('utf-8'))
def c_array(ctype, values):
"""Convert a python array to c array."""
return (ctype * len(values))(*values)
def param_dict_to_str(data):
if data is None or not data:
return ""
pairs = []
for key, val in data.items():
if isinstance(val, (list, tuple, set)) or is_numpy_1d_array(val):
pairs.append(str(key) + '=' + ','.join(map(str, val)))
elif isinstance(val, string_type) or isinstance(val, numeric_types) or is_numeric(val):
pairs.append(str(key) + '=' + str(val))
else:
raise TypeError('Unknown type of parameter:%s, got:%s'
% (key, type(val).__name__))
return ' '.join(pairs)
class _temp_file(object):
def __enter__(self):
with NamedTemporaryFile(prefix="lightgbm_tmp_", delete=True) as f:
self.name = f.name
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if os.path.isfile(self.name):
os.remove(self.name)
def readlines(self):
with open(self.name, "r+") as f:
ret = f.readlines()
return ret
def writelines(self, lines):
with open(self.name, "w+") as f:
f.writelines(lines)
"""marco definition of data type in c_api of LightGBM"""
C_API_DTYPE_FLOAT32 = 0
C_API_DTYPE_FLOAT64 = 1
C_API_DTYPE_INT32 = 2
C_API_DTYPE_INT64 = 3
"""Matric is row major in python"""
C_API_IS_ROW_MAJOR = 1
"""marco definition of prediction type in c_api of LightGBM"""
C_API_PREDICT_NORMAL = 0
C_API_PREDICT_RAW_SCORE = 1
C_API_PREDICT_LEAF_INDEX = 2
"""data type of data field"""
FIELD_TYPE_MAPPER = {"label": C_API_DTYPE_FLOAT32,
"weight": C_API_DTYPE_FLOAT32,
"init_score": C_API_DTYPE_FLOAT64,
"group": C_API_DTYPE_INT32}
def c_float_array(data):
"""get pointer of float numpy array / list"""
if is_1d_list(data):
data = np.array(data, copy=False)
if is_numpy_1d_array(data):
if data.dtype == np.float32:
ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
type_data = C_API_DTYPE_FLOAT32
elif data.dtype == np.float64:
ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
type_data = C_API_DTYPE_FLOAT64
else:
raise TypeError("Expected np.float32 or np.float64, met type({})"
.format(data.dtype))
else:
raise TypeError("Unknown type({})".format(type(data).__name__))
return (ptr_data, type_data)
def c_int_array(data):
"""get pointer of int numpy array / list"""
if is_1d_list(data):
data = np.array(data, copy=False)
if is_numpy_1d_array(data):
if data.dtype == np.int32:
ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int32))
type_data = C_API_DTYPE_INT32
elif data.dtype == np.int64:
ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int64))
type_data = C_API_DTYPE_INT64
else:
raise TypeError("Expected np.int32 or np.int64, met type({})"
.format(data.dtype))
else:
raise TypeError("Unknown type({})".format(type(data).__name__))
return (ptr_data, type_data)
PANDAS_DTYPE_MAPPER = {'int8': 'int', 'int16': 'int', 'int32': 'int',
'int64': 'int', 'uint8': 'int', 'uint16': 'int',
'uint32': 'int', 'uint64': 'int', 'float16': 'float',
'float32': 'float', 'float64': 'float', 'bool': 'int'}
def _data_from_pandas(data, feature_name, categorical_feature, pandas_categorical):
if isinstance(data, DataFrame):
if feature_name == 'auto' or feature_name is None:
data = data.rename(columns=str)
cat_cols = data.select_dtypes(include=['category']).columns
if pandas_categorical is None: # train dataset
pandas_categorical = [list(data[col].cat.categories) for col in cat_cols]
else:
if len(cat_cols) != len(pandas_categorical):
raise ValueError('train and valid dataset categorical_feature do not match.')
for col, category in zip(cat_cols, pandas_categorical):
if list(data[col].cat.categories) != list(category):
data[col] = data[col].cat.set_categories(category)
if len(cat_cols): # cat_cols is pandas Index object
data = data.copy() # not alter origin DataFrame
data[cat_cols] = data[cat_cols].apply(lambda x: x.cat.codes)
if categorical_feature is not None:
if feature_name is None:
feature_name = list(data.columns)
if categorical_feature == 'auto':
categorical_feature = list(cat_cols)
else:
categorical_feature = list(categorical_feature) + list(cat_cols)
if feature_name == 'auto':
feature_name = list(data.columns)
data_dtypes = data.dtypes
if not all(dtype.name in PANDAS_DTYPE_MAPPER for dtype in data_dtypes):
bad_fields = [data.columns[i] for i, dtype in
enumerate(data_dtypes) if dtype.name not in PANDAS_DTYPE_MAPPER]
msg = """DataFrame.dtypes for data must be int, float or bool. Did not expect the data types in fields """
raise ValueError(msg + ', '.join(bad_fields))
data = data.values.astype('float')
else:
if feature_name == 'auto':
feature_name = None
if categorical_feature == 'auto':
categorical_feature = None
return data, feature_name, categorical_feature, pandas_categorical
def _label_from_pandas(label):
if isinstance(label, DataFrame):
if len(label.columns) > 1:
raise ValueError('DataFrame for label cannot have multiple columns')
label_dtypes = label.dtypes
if not all(dtype.name in PANDAS_DTYPE_MAPPER for dtype in label_dtypes):
raise ValueError('DataFrame.dtypes for label must be int, float or bool')
label = label.values.astype('float')
return label
def _save_pandas_categorical(file_name, pandas_categorical):
with open(file_name, 'a') as f:
f.write('\npandas_categorical:' + json.dumps(pandas_categorical, default=json_default_with_numpy))
def _load_pandas_categorical(file_name):
with open(file_name, 'r') as f:
last_line = f.readlines()[-1]
if last_line.startswith('pandas_categorical:'):
return json.loads(last_line[len('pandas_categorical:'):])
return None
class _InnerPredictor(object):
"""
A _InnerPredictor of LightGBM.
Only used for prediction, usually used for continued-train
Note: Can convert from Booster, but cannot convert to Booster
"""
def __init__(self, model_file=None, booster_handle=None):
"""Initialize the _InnerPredictor. Not expose to user
Parameters
----------
model_file : string
Path to the model file.
booster_handle : Handle of Booster
use handle to init
"""
self.handle = ctypes.c_void_p()
self.__is_manage_handle = True
if model_file is not None:
"""Prediction task"""
out_num_iterations = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
c_str(model_file),
ctypes.byref(out_num_iterations),
ctypes.byref(self.handle)))
out_num_class = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetNumClasses(
self.handle,
ctypes.byref(out_num_class)))
self.num_class = out_num_class.value
self.num_total_iteration = out_num_iterations.value
self.pandas_categorical = _load_pandas_categorical(model_file)
elif booster_handle is not None:
self.__is_manage_handle = False
self.handle = booster_handle
out_num_class = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetNumClasses(
self.handle,
ctypes.byref(out_num_class)))
self.num_class = out_num_class.value
out_num_iterations = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetCurrentIteration(
self.handle,
ctypes.byref(out_num_iterations)))
self.num_total_iteration = out_num_iterations.value
self.pandas_categorical = None
else:
raise TypeError('Need Model file or Booster handle to create a predictor')
def __del__(self):
if self.__is_manage_handle:
_safe_call(_LIB.LGBM_BoosterFree(self.handle))
def predict(self, data, num_iteration=-1,
raw_score=False, pred_leaf=False, data_has_header=False,
is_reshape=True):
"""
Predict logic
Parameters
----------
data : string/numpy array/scipy.sparse
Data source for prediction
When data type is string, it represents the path of txt file
num_iteration : int
Used iteration for prediction
raw_score : bool
True for predict raw score
pred_leaf : bool
True for predict leaf index
data_has_header : bool
Used for txt data, True if txt data has header
is_reshape : bool
Reshape to (nrow, ncol) if true
Returns
-------
Prediction result
"""
if isinstance(data, Dataset):
raise TypeError("Cannot use Dataset instance for prediction, please use raw data instead")
data = _data_from_pandas(data, None, None, self.pandas_categorical)[0]
predict_type = C_API_PREDICT_NORMAL
if raw_score:
predict_type = C_API_PREDICT_RAW_SCORE
if pred_leaf:
predict_type = C_API_PREDICT_LEAF_INDEX
int_data_has_header = 1 if data_has_header else 0
if num_iteration > self.num_total_iteration:
num_iteration = self.num_total_iteration
if isinstance(data, string_type):
with _temp_file() as f:
_safe_call(_LIB.LGBM_BoosterPredictForFile(
self.handle,
c_str(data),
ctypes.c_int(int_data_has_header),
ctypes.c_int(predict_type),
ctypes.c_int(num_iteration),
c_str(f.name)))
lines = f.readlines()
nrow = len(lines)
preds = [float(token) for line in lines for token in line.split('\t')]
preds = np.array(preds, dtype=np.float64, copy=False)
elif isinstance(data, scipy.sparse.csr_matrix):
preds, nrow = self.__pred_for_csr(data, num_iteration,
predict_type)
elif isinstance(data, scipy.sparse.csc_matrix):
preds, nrow = self.__pred_for_csc(data, num_iteration,
predict_type)
elif isinstance(data, np.ndarray):
preds, nrow = self.__pred_for_np2d(data, num_iteration,
predict_type)
elif isinstance(data, DataFrame):
preds, nrow = self.__pred_for_np2d(data.values, num_iteration,
predict_type)
else:
try:
csr = scipy.sparse.csr_matrix(data)
preds, nrow = self.__pred_for_csr(csr, num_iteration,
predict_type)
except:
raise TypeError('Cannot predict data for type {}'.format(type(data).__name__))
if pred_leaf:
preds = preds.astype(np.int32)
if is_reshape and preds.size != nrow:
if preds.size % nrow == 0:
preds = preds.reshape(nrow, -1)
else:
raise ValueError('Length of predict result (%d) cannot be divide nrow (%d)'
% (preds.size, nrow))
return preds
def __get_num_preds(self, num_iteration, nrow, predict_type):
"""
Get size of prediction result
"""
n_preds = ctypes.c_int64(0)
_safe_call(_LIB.LGBM_BoosterCalcNumPredict(
self.handle,
ctypes.c_int(nrow),
ctypes.c_int(predict_type),
ctypes.c_int(num_iteration),
ctypes.byref(n_preds)))
return n_preds.value
def __pred_for_np2d(self, mat, num_iteration, predict_type):
"""
Predict for a 2-D numpy matrix.
"""
if len(mat.shape) != 2:
raise ValueError('Input numpy.ndarray must be 2 dimensional')
if mat.dtype == np.float32 or mat.dtype == np.float64:
data = np.array(mat.reshape(mat.size), dtype=mat.dtype, copy=False)
else:
"""change non-float data to float data, need to copy"""
data = np.array(mat.reshape(mat.size), dtype=np.float32)
ptr_data, type_ptr_data = c_float_array(data)
n_preds = self.__get_num_preds(num_iteration, mat.shape[0],
predict_type)
preds = np.zeros(n_preds, dtype=np.float64)
out_num_preds = ctypes.c_int64(0)
_safe_call(_LIB.LGBM_BoosterPredictForMat(
self.handle,
ptr_data,
ctypes.c_int(type_ptr_data),
ctypes.c_int(mat.shape[0]),
ctypes.c_int(mat.shape[1]),
ctypes.c_int(C_API_IS_ROW_MAJOR),
ctypes.c_int(predict_type),
ctypes.c_int(num_iteration),
ctypes.byref(out_num_preds),
preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
if n_preds != out_num_preds.value:
raise ValueError("Wrong length for predict results")
return preds, mat.shape[0]
def __pred_for_csr(self, csr, num_iteration, predict_type):
"""
Predict for a csr data
"""
nrow = len(csr.indptr) - 1
n_preds = self.__get_num_preds(num_iteration, nrow, predict_type)
preds = np.zeros(n_preds, dtype=np.float64)
out_num_preds = ctypes.c_int64(0)
ptr_indptr, type_ptr_indptr = c_int_array(csr.indptr)
ptr_data, type_ptr_data = c_float_array(csr.data)
_safe_call(_LIB.LGBM_BoosterPredictForCSR(
self.handle,
ptr_indptr,
ctypes.c_int32(type_ptr_indptr),
csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
ptr_data,
ctypes.c_int(type_ptr_data),
ctypes.c_int64(len(csr.indptr)),
ctypes.c_int64(len(csr.data)),
ctypes.c_int64(csr.shape[1]),
ctypes.c_int(predict_type),
ctypes.c_int(num_iteration),
ctypes.byref(out_num_preds),
preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
if n_preds != out_num_preds.value:
raise ValueError("Wrong length for predict results")
return preds, nrow
def __pred_for_csc(self, csc, num_iteration, predict_type):
"""
Predict for a csc data
"""
nrow = csc.shape[0]
n_preds = self.__get_num_preds(num_iteration, nrow, predict_type)
preds = np.zeros(n_preds, dtype=np.float64)
out_num_preds = ctypes.c_int64(0)
ptr_indptr, type_ptr_indptr = c_int_array(csc.indptr)
ptr_data, type_ptr_data = c_float_array(csc.data)
_safe_call(_LIB.LGBM_BoosterPredictForCSC(
self.handle,
ptr_indptr,
ctypes.c_int32(type_ptr_indptr),
csc.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
ptr_data,
ctypes.c_int(type_ptr_data),
ctypes.c_int64(len(csc.indptr)),
ctypes.c_int64(len(csc.data)),
ctypes.c_int64(csc.shape[0]),
ctypes.c_int(predict_type),
ctypes.c_int(num_iteration),
ctypes.byref(out_num_preds),
preds.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
if n_preds != out_num_preds.value:
raise ValueError("Wrong length for predict results")
return preds, nrow
class Dataset(object):
"""Dataset in LightGBM."""
def __init__(self, data, label=None, max_bin=255, reference=None,
weight=None, group=None, silent=False,
feature_name='auto', categorical_feature='auto', params=None,
free_raw_data=True):
"""
Parameters
----------
data : string/numpy array/scipy.sparse
Data source of Dataset.
When data type is string, it represents the path of txt file
label : list or numpy 1-D array, optional
Label of the data
max_bin : int, required
Max number of discrete bin for features
reference : Other Dataset, optional
If this dataset validation, need to use training data as reference
weight : list or numpy 1-D array , optional
Weight for each instance.
group : list or numpy 1-D array , optional
Group/query size for dataset
silent : boolean, optional
Whether print messages during construction
feature_name : list of str, or 'auto'
Feature names
If 'auto' and data is pandas DataFrame, use data columns name
categorical_feature : list of str or int, or 'auto'
Categorical features,
type int represents index,
type str represents feature names (need to specify feature_name as well)
If 'auto' and data is pandas DataFrame, use pandas categorical columns
params: dict, optional
Other parameters
free_raw_data: Bool
True if need to free raw data after construct inner dataset
"""
self.handle = None
self.data = data
self.label = label
self.max_bin = max_bin
self.reference = reference
self.weight = weight
self.group = group
self.silent = silent
self.feature_name = feature_name
self.categorical_feature = categorical_feature
self.params = params
self.free_raw_data = free_raw_data
self.used_indices = None
self._predictor = None
self.pandas_categorical = None
def __del__(self):
self._free_handle()
def _free_handle(self):
if self.handle is not None:
_safe_call(_LIB.LGBM_DatasetFree(self.handle))
self.handle = None
def _lazy_init(self, data, label=None, max_bin=255, reference=None,
weight=None, group=None, predictor=None,
silent=False, feature_name='auto',
categorical_feature='auto', params=None):
if data is None:
self.handle = None
return
data, feature_name, categorical_feature, self.pandas_categorical = _data_from_pandas(data, feature_name, categorical_feature, self.pandas_categorical)
label = _label_from_pandas(label)
self.data_has_header = False
"""process for args"""
params = {} if params is None else params
self.max_bin = max_bin
self.predictor = predictor
params["max_bin"] = max_bin
if silent:
params["verbose"] = 0
elif "verbose" not in params:
params["verbose"] = 1
"""get categorical features"""
if categorical_feature is not None:
categorical_indices = set()
feature_dict = {}
if feature_name is not None:
feature_dict = {name: i for i, name in enumerate(feature_name)}
for name in categorical_feature:
if isinstance(name, string_type) and name in feature_dict:
categorical_indices.add(feature_dict[name])
elif isinstance(name, integer_types):
categorical_indices.add(name)
else:
raise TypeError("Wrong type({}) or unknown name({}) in categorical_feature"
.format(type(name).__name__, name))
params['categorical_column'] = sorted(categorical_indices)
params_str = param_dict_to_str(params)
"""process for reference dataset"""
ref_dataset = None
if isinstance(reference, Dataset):
ref_dataset = reference.construct().handle
elif reference is not None:
raise TypeError('Reference dataset should be None or dataset instance')
"""start construct data"""
if isinstance(data, string_type):
"""check data has header or not"""
if str(params.get("has_header", "")).lower() == "true" \
or str(params.get("header", "")).lower() == "true":
self.data_has_header = True
self.handle = ctypes.c_void_p()
_safe_call(_LIB.LGBM_DatasetCreateFromFile(
c_str(data),
c_str(params_str),
ref_dataset,
ctypes.byref(self.handle)))
elif isinstance(data, scipy.sparse.csr_matrix):
self.__init_from_csr(data, params_str, ref_dataset)
elif isinstance(data, scipy.sparse.csc_matrix):
self.__init_from_csc(data, params_str, ref_dataset)
elif isinstance(data, np.ndarray):
self.__init_from_np2d(data, params_str, ref_dataset)
else:
try:
csr = scipy.sparse.csr_matrix(data)
self.__init_from_csr(csr, params_str, ref_dataset)
except:
raise TypeError('Cannot initialize Dataset from {}'.format(type(data).__name__))
if label is not None:
self.set_label(label)
if self.get_label() is None:
raise ValueError("Label should not be None")
if weight is not None:
self.set_weight(weight)
if group is not None:
self.set_group(group)
# load init score
if isinstance(self.predictor, _InnerPredictor):
init_score = self.predictor.predict(data,
raw_score=True,
data_has_header=self.data_has_header,
is_reshape=False)
if self.predictor.num_class > 1:
# need re group init score
new_init_score = np.zeros(init_score.size, dtype=np.float32)
num_data = self.num_data()
for i in range_(num_data):
for j in range_(self.predictor.num_class):
new_init_score[j * num_data + i] = init_score[i * self.predictor.num_class + j]
init_score = new_init_score
self.set_init_score(init_score)
elif self.predictor is not None:
raise TypeError('wrong predictor type {}'.format(type(self.predictor).__name__))
# set feature names
self.set_feature_name(feature_name)
def __init_from_np2d(self, mat, params_str, ref_dataset):
"""
Initialize data from a 2-D numpy matrix.
"""
if len(mat.shape) != 2:
raise ValueError('Input numpy.ndarray must be 2 dimensional')
self.handle = ctypes.c_void_p()
if mat.dtype == np.float32 or mat.dtype == np.float64:
data = np.array(mat.reshape(mat.size), dtype=mat.dtype, copy=False)
else:
"""change non-float data to float data, need to copy"""
data = np.array(mat.reshape(mat.size), dtype=np.float32)
ptr_data, type_ptr_data = c_float_array(data)
_safe_call(_LIB.LGBM_DatasetCreateFromMat(
ptr_data,
ctypes.c_int(type_ptr_data),
ctypes.c_int(mat.shape[0]),
ctypes.c_int(mat.shape[1]),
ctypes.c_int(C_API_IS_ROW_MAJOR),
c_str(params_str),
ref_dataset,
ctypes.byref(self.handle)))
def __init_from_csr(self, csr, params_str, ref_dataset):
"""
Initialize data from a CSR matrix.
"""
if len(csr.indices) != len(csr.data):
raise ValueError('Length mismatch: {} vs {}'.format(len(csr.indices), len(csr.data)))
self.handle = ctypes.c_void_p()
ptr_indptr, type_ptr_indptr = c_int_array(csr.indptr)
ptr_data, type_ptr_data = c_float_array(csr.data)
_safe_call(_LIB.LGBM_DatasetCreateFromCSR(
ptr_indptr,
ctypes.c_int(type_ptr_indptr),
csr.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
ptr_data,
ctypes.c_int(type_ptr_data),
ctypes.c_int64(len(csr.indptr)),
ctypes.c_int64(len(csr.data)),
ctypes.c_int64(csr.shape[1]),
c_str(params_str),
ref_dataset,
ctypes.byref(self.handle)))
def __init_from_csc(self, csc, params_str, ref_dataset):
"""
Initialize data from a csc matrix.
"""
if len(csc.indices) != len(csc.data):
raise ValueError('Length mismatch: {} vs {}'.format(len(csc.indices), len(csc.data)))
self.handle = ctypes.c_void_p()
ptr_indptr, type_ptr_indptr = c_int_array(csc.indptr)
ptr_data, type_ptr_data = c_float_array(csc.data)
_safe_call(_LIB.LGBM_DatasetCreateFromCSC(
ptr_indptr,
ctypes.c_int(type_ptr_indptr),
csc.indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
ptr_data,
ctypes.c_int(type_ptr_data),
ctypes.c_int64(len(csc.indptr)),
ctypes.c_int64(len(csc.data)),
ctypes.c_int64(csc.shape[0]),
c_str(params_str),
ref_dataset,
ctypes.byref(self.handle)))
def construct(self):
"""Lazy init"""
if self.handle is None:
if self.reference is not None:
if self.used_indices is None:
"""create valid"""
self._lazy_init(self.data, label=self.label, max_bin=self.max_bin, reference=self.reference,
weight=self.weight, group=self.group, predictor=self._predictor,
silent=self.silent, params=self.params)
else:
"""construct subset"""
used_indices = list_to_1d_numpy(self.used_indices, np.int32, name='used_indices')
self.handle = ctypes.c_void_p()
params_str = param_dict_to_str(self.params)
_safe_call(_LIB.LGBM_DatasetGetSubset(
self.reference.construct().handle,
used_indices.ctypes.data_as(ctypes.POINTER(ctypes.c_int32)),
ctypes.c_int(used_indices.shape[0]),
c_str(params_str),
ctypes.byref(self.handle)))
if self.get_label() is None:
raise ValueError("Label should not be None.")
else:
"""create train"""
self._lazy_init(self.data, label=self.label, max_bin=self.max_bin,
weight=self.weight, group=self.group, predictor=self._predictor,
silent=self.silent, feature_name=self.feature_name,
categorical_feature=self.categorical_feature, params=self.params)
if self.free_raw_data:
self.data = None
return self
def create_valid(self, data, label=None, weight=None, group=None,
silent=False, params=None):
"""
Create validation data align with current dataset
Parameters
----------
data : string/numpy array/scipy.sparse
Data source of Dataset.
When data type is string, it represents the path of txt file
label : list or numpy 1-D array, optional
Label of the training data.
weight : list or numpy 1-D array , optional
Weight for each instance.
group : list or numpy 1-D array , optional
Group/query size for dataset
silent : boolean, optional
Whether print messages during construction
params: dict, optional
Other parameters
"""
ret = Dataset(data, label=label, max_bin=self.max_bin, reference=self,
weight=weight, group=group, silent=silent, params=params,
free_raw_data=self.free_raw_data)
ret._predictor = self._predictor
ret.pandas_categorical = self.pandas_categorical
return ret
def subset(self, used_indices, params=None):
"""
Get subset of current dataset
Parameters
----------
used_indices : list of int
Used indices of this subset
params : dict
Other parameters
"""
ret = Dataset(None, reference=self, feature_name=self.feature_name,
categorical_feature=self.categorical_feature, params=params)
ret._predictor = self._predictor
ret.pandas_categorical = self.pandas_categorical
ret.used_indices = used_indices
return ret
def save_binary(self, filename):
"""
Save Dataset to binary file
Parameters
----------
filename : string
Name of the output file.
"""
_safe_call(_LIB.LGBM_DatasetSaveBinary(
self.construct().handle,
c_str(filename)))
def _update_params(self, params):
if not self.params:
self.params = params
else:
self.params.update(params)
def set_field(self, field_name, data):
"""Set property into the Dataset.
Parameters
----------
field_name: str
The field name of the information
data: numpy array or list or None
The array ofdata to be set
"""
if self.handle is None:
raise Exception("Cannot set %s before construct dataset" % field_name)
if data is None:
"""set to None"""
_safe_call(_LIB.LGBM_DatasetSetField(
self.handle,
c_str(field_name),
None,
ctypes.c_int(0),
ctypes.c_int(FIELD_TYPE_MAPPER[field_name])))
return
dtype = np.float32
if field_name == 'group':
dtype = np.int32
elif field_name == 'init_score':
dtype = np.float64
data = list_to_1d_numpy(data, dtype, name=field_name)
if data.dtype == np.float32:
ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
type_data = C_API_DTYPE_FLOAT32
elif data.dtype == np.float64:
ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
type_data = C_API_DTYPE_FLOAT64
elif data.dtype == np.int32:
ptr_data = data.ctypes.data_as(ctypes.POINTER(ctypes.c_int32))
type_data = C_API_DTYPE_INT32
else:
raise TypeError("Excepted np.float32/64 or np.int32, meet type({})".format(data.dtype))
if type_data != FIELD_TYPE_MAPPER[field_name]:
raise TypeError("Input type error for set_field")
_safe_call(_LIB.LGBM_DatasetSetField(
self.handle,
c_str(field_name),
ptr_data,
ctypes.c_int(len(data)),
ctypes.c_int(type_data)))
def get_field(self, field_name):
"""Get property from the Dataset.
Parameters
----------
field_name: str
The field name of the information
Returns
-------
info : array
A numpy array of information of the data
"""
if self.handle is None:
raise Exception("Cannot get %s before construct dataset" % field_name)
tmp_out_len = ctypes.c_int()
out_type = ctypes.c_int()
ret = ctypes.POINTER(ctypes.c_void_p)()
_safe_call(_LIB.LGBM_DatasetGetField(
self.handle,
c_str(field_name),
ctypes.byref(tmp_out_len),
ctypes.byref(ret),
ctypes.byref(out_type)))
if out_type.value != FIELD_TYPE_MAPPER[field_name]:
raise TypeError("Return type error for get_field")
if tmp_out_len.value == 0:
return None
if out_type.value == C_API_DTYPE_INT32:
return cint32_array_to_numpy(ctypes.cast(ret, ctypes.POINTER(ctypes.c_int32)), tmp_out_len.value)
elif out_type.value == C_API_DTYPE_FLOAT32:
return cfloat32_array_to_numpy(ctypes.cast(ret, ctypes.POINTER(ctypes.c_float)), tmp_out_len.value)
elif out_type.value == C_API_DTYPE_FLOAT64:
return cfloat64_array_to_numpy(ctypes.cast(ret, ctypes.POINTER(ctypes.c_double)), tmp_out_len.value)
else:
raise TypeError("Unknown type")
def set_categorical_feature(self, categorical_feature):
"""
Set categorical features
Parameters
----------
categorical_feature : list of int or str
Name/index of categorical features
"""
if self.categorical_feature == categorical_feature:
return
if self.data is not None:
self.categorical_feature = categorical_feature
self._free_handle()
else:
raise LightGBMError("Cannot set categorical feature after freed raw data, set free_raw_data=False when construct Dataset to avoid this.")
def _set_predictor(self, predictor):
"""
Set predictor for continued training, not recommand for user to call this function.
Please set init_model in engine.train or engine.cv
"""
if predictor is self._predictor:
return
if self.data is not None:
self._predictor = predictor
self._free_handle()
else:
raise LightGBMError("Cannot set predictor after freed raw data, set free_raw_data=False when construct Dataset to avoid this.")
def set_reference(self, reference):
"""
Set reference dataset
Parameters
----------
reference : Dataset
Will use reference as template to consturct current dataset
"""
self.set_categorical_feature(reference.categorical_feature)
self.set_feature_name(reference.feature_name)
self._set_predictor(reference._predictor)
if self.reference is reference:
return
if self.data is not None:
self.reference = reference
self._free_handle()
else:
raise LightGBMError("Cannot set reference after freed raw data, set free_raw_data=False when construct Dataset to avoid this.")
def set_feature_name(self, feature_name):
"""
Set feature name
Parameters
----------
feature_name : list of str
Feature names
"""
self.feature_name = feature_name
if self.handle is not None and feature_name is not None and feature_name != 'auto':
if len(feature_name) != self.num_feature():
raise ValueError("Length of feature_name({}) and num_feature({}) don't match".format(len(feature_name), self.num_feature()))
c_feature_name = [c_str(name) for name in feature_name]
_safe_call(_LIB.LGBM_DatasetSetFeatureNames(
self.handle,
c_array(ctypes.c_char_p, c_feature_name),
ctypes.c_int(len(feature_name))))
def set_label(self, label):
"""
Set label of Dataset
Parameters
----------
label: numpy array or list or None
The label information to be set into Dataset
"""
self.label = label
if self.handle is not None:
label = list_to_1d_numpy(label, name='label')
self.set_field('label', label)
def set_weight(self, weight):
"""
Set weight of each instance.
Parameters
----------
weight : numpy array or list or None
Weight for each data point
"""
self.weight = weight
if self.handle is not None and weight is not None:
weight = list_to_1d_numpy(weight, name='weight')
self.set_field('weight', weight)
def set_init_score(self, init_score):
"""
Set init score of booster to start from.
Parameters
----------
init_score: numpy array or list or None
Init score for booster
"""
self.init_score = init_score
if self.handle is not None and init_score is not None:
init_score = list_to_1d_numpy(init_score, np.float64, name='init_score')
self.set_field('init_score', init_score)
def set_group(self, group):
"""
Set group size of Dataset (used for ranking).
Parameters
----------
group : numpy array or list or None
Group size of each group
"""
self.group = group
if self.handle is not None and group is not None:
group = list_to_1d_numpy(group, np.int32, name='group')
self.set_field('group', group)
def get_label(self):
"""
Get the label of the Dataset.
Returns
-------
label : array
"""
if self.label is None and self.handle is not None:
self.label = self.get_field('label')
return self.label
def get_weight(self):
"""
Get the weight of the Dataset.
Returns
-------
weight : array
"""
if self.weight is None and self.handle is not None:
self.weight = self.get_field('weight')
return self.weight
def get_init_score(self):
"""
Get the initial score of the Dataset.
Returns
-------
init_score : array
"""
if self.init_score is None and self.handle is not None:
self.init_score = self.get_field('init_score')
return self.init_score
def get_group(self):
"""
Get the initial score of the Dataset.
Returns
-------
init_score : array
"""
if self.group is None and self.handle is not None:
self.group = self.get_field('group')
if self.group is not None:
# group data from LightGBM is boundaries data, need to convert to group size
new_group = []
for i in range_(len(self.group) - 1):
new_group.append(self.group[i + 1] - self.group[i])
self.group = new_group
return self.group
def num_data(self):
"""
Get the number of rows in the Dataset.
Returns
-------
number of rows : int
"""
if self.handle is not None:
ret = ctypes.c_int()
_safe_call(_LIB.LGBM_DatasetGetNumData(self.handle,
ctypes.byref(ret)))
return ret.value
else:
raise LightGBMError("Cannot get num_data before construct dataset")
def num_feature(self):
"""
Get the number of columns (features) in the Dataset.
Returns
-------
number of columns : int
"""
if self.handle is not None:
ret = ctypes.c_int()
_safe_call(_LIB.LGBM_DatasetGetNumFeature(self.handle,
ctypes.byref(ret)))
return ret.value
else:
raise LightGBMError("Cannot get num_feature before construct dataset")
class Booster(object):
""""Booster in LightGBM."""
def __init__(self, params=None, train_set=None, model_file=None, silent=False):
"""
Initialize the Booster.
Parameters
----------
params : dict
Parameters for boosters.
train_set : Dataset
Training dataset
model_file : string
Path to the model file.
silent : boolean, optional
Whether print messages during construction
"""
self.handle = ctypes.c_void_p()
self.__need_reload_eval_info = True
self.__train_data_name = "training"
self.__attr = {}
self.best_iteration = -1
params = {} if params is None else params
if silent:
params["verbose"] = 0
elif "verbose" not in params:
params["verbose"] = 1
if train_set is not None:
"""Training task"""
if not isinstance(train_set, Dataset):
raise TypeError('Training data should be Dataset instance, met {}'.format(type(train_set).__name__))
params_str = param_dict_to_str(params)
"""construct booster object"""
_safe_call(_LIB.LGBM_BoosterCreate(
train_set.construct().handle,
c_str(params_str),
ctypes.byref(self.handle)))
"""save reference to data"""
self.train_set = train_set
self.valid_sets = []
self.name_valid_sets = []
self.__num_dataset = 1
self.__init_predictor = train_set._predictor
if self.__init_predictor is not None:
_safe_call(_LIB.LGBM_BoosterMerge(
self.handle,
self.__init_predictor.handle))
out_num_class = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetNumClasses(
self.handle,
ctypes.byref(out_num_class)))
self.__num_class = out_num_class.value
"""buffer for inner predict"""
self.__inner_predict_buffer = [None]
self.__is_predicted_cur_iter = [False]
self.__get_eval_info()
self.pandas_categorical = train_set.pandas_categorical
elif model_file is not None:
"""Prediction task"""
out_num_iterations = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterCreateFromModelfile(
c_str(model_file),
ctypes.byref(out_num_iterations),
ctypes.byref(self.handle)))
out_num_class = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetNumClasses(
self.handle,
ctypes.byref(out_num_class)))
self.__num_class = out_num_class.value
self.pandas_categorical = _load_pandas_categorical(model_file)
elif 'model_str' in params:
self.__load_model_from_string(params['model_str'])
else:
raise TypeError('Need at least one training dataset or model file to create booster instance')
def __del__(self):
if self.handle is not None:
_safe_call(_LIB.LGBM_BoosterFree(self.handle))
def __copy__(self):
return self.__deepcopy__(None)
def __deepcopy__(self, _):
model_str = self.__save_model_to_string()
booster = Booster({'model_str': model_str})
booster.pandas_categorical = self.pandas_categorical
return booster
def __getstate__(self):
this = self.__dict__.copy()
handle = this['handle']
this.pop('train_set', None)
this.pop('valid_sets', None)
if handle is not None:
this["handle"] = self.__save_model_to_string()
return this
def __setstate__(self, state):
model_str = state.get('handle', None)
if model_str is not None:
handle = ctypes.c_void_p()
out_num_iterations = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterLoadModelFromString(
c_str(model_str),
ctypes.byref(out_num_iterations),
ctypes.byref(handle)))
state['handle'] = handle
self.__dict__.update(state)
def set_train_data_name(self, name):
self.__train_data_name = name
def add_valid(self, data, name):
"""
Add an validation data
Parameters
----------
data : Dataset
Validation data
name : String
Name of validation data
"""
if not isinstance(data, Dataset):
raise TypeError('valid data should be Dataset instance, met {}'.format(type(data).__name__))
if data._predictor is not self.__init_predictor:
raise LightGBMError("Add validation data failed, you should use same predictor for these data")
_safe_call(_LIB.LGBM_BoosterAddValidData(
self.handle,
data.construct().handle))
self.valid_sets.append(data)
self.name_valid_sets.append(name)
self.__num_dataset += 1
self.__inner_predict_buffer.append(None)
self.__is_predicted_cur_iter.append(False)
def reset_parameter(self, params):
"""
Reset parameters for booster
Parameters
----------
params : dict
New parameters for boosters
silent : boolean, optional
Whether print messages during construction
"""
if 'metric' in params:
self.__need_reload_eval_info = True
params_str = param_dict_to_str(params)
if params_str:
_safe_call(_LIB.LGBM_BoosterResetParameter(
self.handle,
c_str(params_str)))
def update(self, train_set=None, fobj=None):
"""
Update for one iteration
Note: for multi-class task, the score is group by class_id first, then group by row_id
if you want to get i-th row score in j-th class, the access way is score[j*num_data+i]
and you should group grad and hess in this way as well
Parameters
----------
train_set :
Training data, None means use last training data
fobj : function
Customized objective function.
Returns
-------
is_finished, bool
"""
"""need reset training data"""
if train_set is not None and train_set is not self.train_set:
if not isinstance(train_set, Dataset):
raise TypeError('Training data should be Dataset instance, met {}'.format(type(train_set).__name__))
if train_set._predictor is not self.__init_predictor:
raise LightGBMError("Replace training data failed, you should use same predictor for these data")
self.train_set = train_set
_safe_call(_LIB.LGBM_BoosterResetTrainingData(
self.handle,
self.train_set.construct().handle))
self.__inner_predict_buffer[0] = None
is_finished = ctypes.c_int(0)
if fobj is None:
_safe_call(_LIB.LGBM_BoosterUpdateOneIter(
self.handle,
ctypes.byref(is_finished)))
self.__is_predicted_cur_iter = [False for _ in range_(self.__num_dataset)]
return is_finished.value == 1
else:
grad, hess = fobj(self.__inner_predict(0), self.train_set)
return self.__boost(grad, hess)
def __boost(self, grad, hess):
"""
Boost the booster for one iteration, with customized gradient statistics.
Note: for multi-class task, the score is group by class_id first, then group by row_id
if you want to get i-th row score in j-th class, the access way is score[j*num_data+i]
and you should group grad and hess in this way as well
Parameters
----------
grad : 1d numpy or 1d list
The first order of gradient.
hess : 1d numpy or 1d list
The second order of gradient.
Returns
-------
is_finished, bool
"""
grad = list_to_1d_numpy(grad, name='gradient')
hess = list_to_1d_numpy(hess, name='hessian')
if len(grad) != len(hess):
raise ValueError("Lengths of gradient({}) and hessian({}) don't match".format(len(grad), len(hess)))
is_finished = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterUpdateOneIterCustom(
self.handle,
grad.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
hess.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
ctypes.byref(is_finished)))
self.__is_predicted_cur_iter = [False for _ in range_(self.__num_dataset)]
return is_finished.value == 1
def rollback_one_iter(self):
"""
Rollback one iteration
"""
_safe_call(_LIB.LGBM_BoosterRollbackOneIter(
self.handle))
self.__is_predicted_cur_iter = [False for _ in range_(self.__num_dataset)]
def current_iteration(self):
out_cur_iter = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetCurrentIteration(
self.handle,
ctypes.byref(out_cur_iter)))
return out_cur_iter.value
def eval(self, data, name, feval=None):
"""
Evaluate for data
Parameters
----------
data : Dataset object
name :
Name of data
feval : function
Custom evaluation function.
Returns
-------
result: list
Evaluation result list.
"""
if not isinstance(data, Dataset):
raise TypeError("Can only eval for Dataset instance")
data_idx = -1
if data is self.train_set:
data_idx = 0
else:
for i in range_(len(self.valid_sets)):
if data is self.valid_sets[i]:
data_idx = i + 1
break
"""need to push new valid data"""
if data_idx == -1:
self.add_valid(data, name)
data_idx = self.__num_dataset - 1
return self.__inner_eval(name, data_idx, feval)
def eval_train(self, feval=None):
"""
Evaluate for training data
Parameters
----------
feval : function
Custom evaluation function.
Returns
-------
result: str
Evaluation result list.
"""
return self.__inner_eval(self.__train_data_name, 0, feval)
def eval_valid(self, feval=None):
"""
Evaluate for validation data
Parameters
----------
feval : function
Custom evaluation function.
Returns
-------
result: str
Evaluation result list.
"""
return [item for i in range_(1, self.__num_dataset)
for item in self.__inner_eval(self.name_valid_sets[i - 1], i, feval)]
def save_model(self, filename, num_iteration=-1):
"""
Save model of booster to file
Parameters
----------
filename : str
Filename to save
num_iteration: int
Number of iteration that want to save. < 0 means save the best iteration(if have)
"""
if num_iteration <= 0:
num_iteration = self.best_iteration
_safe_call(_LIB.LGBM_BoosterSaveModel(
self.handle,
ctypes.c_int(num_iteration),
c_str(filename)))
_save_pandas_categorical(filename, self.pandas_categorical)
def __load_model_from_string(self, model_str):
"""[Private] Load model from string"""
out_num_iterations = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterLoadModelFromString(
c_str(model_str),
ctypes.byref(out_num_iterations),
ctypes.byref(self.handle)))
out_num_class = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetNumClasses(
self.handle,
ctypes.byref(out_num_class)))
self.__num_class = out_num_class.value
def __save_model_to_string(self, num_iteration=-1):
"""[Private] Save model to string"""
if num_iteration <= 0:
num_iteration = self.best_iteration
buffer_len = 1 << 20
tmp_out_len = ctypes.c_int(0)
string_buffer = ctypes.create_string_buffer(buffer_len)
ptr_string_buffer = ctypes.c_char_p(*[ctypes.addressof(string_buffer)])
_safe_call(_LIB.LGBM_BoosterSaveModelToString(
self.handle,
ctypes.c_int(num_iteration),
ctypes.c_int(buffer_len),
ctypes.byref(tmp_out_len),
ptr_string_buffer))
actual_len = tmp_out_len.value
'''if buffer length is not long enough, re-allocate a buffer'''
if actual_len > buffer_len:
string_buffer = ctypes.create_string_buffer(actual_len)
ptr_string_buffer = ctypes.c_char_p(*[ctypes.addressof(string_buffer)])
_safe_call(_LIB.LGBM_BoosterSaveModelToString(
self.handle,
ctypes.c_int(num_iteration),
ctypes.c_int(actual_len),
ctypes.byref(tmp_out_len),
ptr_string_buffer))
return string_buffer.value.decode()
def dump_model(self, num_iteration=-1):
"""
Dump model to json format
Parameters
----------
num_iteration: int
Number of iteration that want to dump. < 0 means dump to best iteration(if have)
Returns
-------
Json format of model
"""
if num_iteration <= 0:
num_iteration = self.best_iteration
buffer_len = 1 << 20
tmp_out_len = ctypes.c_int(0)
string_buffer = ctypes.create_string_buffer(buffer_len)
ptr_string_buffer = ctypes.c_char_p(*[ctypes.addressof(string_buffer)])
_safe_call(_LIB.LGBM_BoosterDumpModel(
self.handle,
ctypes.c_int(num_iteration),
ctypes.c_int(buffer_len),
ctypes.byref(tmp_out_len),
ptr_string_buffer))
actual_len = tmp_out_len.value
'''if buffer length is not long enough, reallocate a buffer'''
if actual_len > buffer_len:
string_buffer = ctypes.create_string_buffer(actual_len)
ptr_string_buffer = ctypes.c_char_p(*[ctypes.addressof(string_buffer)])
_safe_call(_LIB.LGBM_BoosterDumpModel(
self.handle,
ctypes.c_int(num_iteration),
ctypes.c_int(actual_len),
ctypes.byref(tmp_out_len),
ptr_string_buffer))
return json.loads(string_buffer.value.decode())
def predict(self, data, num_iteration=-1, raw_score=False, pred_leaf=False, data_has_header=False, is_reshape=True):
"""
Predict logic
Parameters
----------
data : string/numpy array/scipy.sparse
Data source for prediction
When data type is string, it represents the path of txt file
num_iteration : int
Used iteration for prediction, < 0 means predict for best iteration(if have)
raw_score : bool
True for predict raw score
pred_leaf : bool
True for predict leaf index
data_has_header : bool
Used for txt data
is_reshape : bool
Reshape to (nrow, ncol) if true
Returns
-------
Prediction result
"""
predictor = self._to_predictor()
if num_iteration <= 0:
num_iteration = self.best_iteration
return predictor.predict(data, num_iteration, raw_score, pred_leaf, data_has_header, is_reshape)
def _to_predictor(self):
"""Convert to predictor
"""
predictor = _InnerPredictor(booster_handle=self.handle)
predictor.pandas_categorical = self.pandas_categorical
return predictor
def feature_importance(self, importance_type='split'):
"""
Feature importances
Parameters
----------
importance_type : str, default "split"
How the importance is calculated: "split" or "gain"
"split" is the number of times a feature is used in a model
"gain" is the total gain of splits which use the feature
Returns
-------
Array of feature importances
"""
if importance_type not in ["split", "gain"]:
raise KeyError("importance_type must be split or gain")
dump_model = self.dump_model()
ret = [0] * (dump_model["max_feature_idx"] + 1)
def dfs(root):
if "split_feature" in root:
if importance_type == 'split':
ret[root["split_feature"]] += 1
elif importance_type == 'gain':
ret[root["split_feature"]] += root["split_gain"]
dfs(root["left_child"])
dfs(root["right_child"])
for tree in dump_model["tree_info"]:
dfs(tree["tree_structure"])
return np.array(ret)
def __inner_eval(self, data_name, data_idx, feval=None):
"""
Evaulate training or validation data
"""
if data_idx >= self.__num_dataset:
raise ValueError("Data_idx should be smaller than number of dataset")
self.__get_eval_info()
ret = []
if self.__num_inner_eval > 0:
result = np.array([0.0 for _ in range_(self.__num_inner_eval)], dtype=np.float64)
tmp_out_len = ctypes.c_int(0)
_safe_call(_LIB.LGBM_BoosterGetEval(
self.handle,
ctypes.c_int(data_idx),
ctypes.byref(tmp_out_len),
result.ctypes.data_as(ctypes.POINTER(ctypes.c_double))))
if tmp_out_len.value != self.__num_inner_eval:
raise ValueError("Wrong length of eval results")
for i in range_(self.__num_inner_eval):
ret.append((data_name, self.__name_inner_eval[i], result[i], self.__higher_better_inner_eval[i]))
if feval is not None:
if data_idx == 0:
cur_data = self.train_set
else:
cur_data = self.valid_sets[data_idx - 1]
feval_ret = feval(self.__inner_predict(data_idx), cur_data)
if isinstance(feval_ret, list):
for eval_name, val, is_higher_better in feval_ret:
ret.append((data_name, eval_name, val, is_higher_better))
else:
eval_name, val, is_higher_better = feval_ret
ret.append((data_name, eval_name, val, is_higher_better))
return ret
def __inner_predict(self, data_idx):
"""
Predict for training and validation dataset
"""
if data_idx >= self.__num_dataset:
raise ValueError("Data_idx should be smaller than number of dataset")
if self.__inner_predict_buffer[data_idx] is None:
if data_idx == 0:
n_preds = self.train_set.num_data() * self.__num_class
else:
n_preds = self.valid_sets[data_idx - 1].num_data() * self.__num_class
self.__inner_predict_buffer[data_idx] = \
np.array([0.0 for _ in range_(n_preds)], dtype=np.float64, copy=False)
"""avoid to predict many time in one iteration"""
if not self.__is_predicted_cur_iter[data_idx]:
tmp_out_len = ctypes.c_int64(0)
data_ptr = self.__inner_predict_buffer[data_idx].ctypes.data_as(ctypes.POINTER(ctypes.c_double))
_safe_call(_LIB.LGBM_BoosterGetPredict(
self.handle,
ctypes.c_int(data_idx),
ctypes.byref(tmp_out_len),
data_ptr))
if tmp_out_len.value != len(self.__inner_predict_buffer[data_idx]):
raise ValueError("Wrong length of predict results for data %d" % (data_idx))
self.__is_predicted_cur_iter[data_idx] = True
return self.__inner_predict_buffer[data_idx]
def __get_eval_info(self):
"""
Get inner evaluation count and names
"""
if self.__need_reload_eval_info:
self.__need_reload_eval_info = False
out_num_eval = ctypes.c_int(0)
"""Get num of inner evals"""
_safe_call(_LIB.LGBM_BoosterGetEvalCounts(
self.handle,
ctypes.byref(out_num_eval)))
self.__num_inner_eval = out_num_eval.value
if self.__num_inner_eval > 0:
"""Get name of evals"""
tmp_out_len = ctypes.c_int(0)
string_buffers = [ctypes.create_string_buffer(255) for i in range_(self.__num_inner_eval)]
ptr_string_buffers = (ctypes.c_char_p * self.__num_inner_eval)(*map(ctypes.addressof, string_buffers))
_safe_call(_LIB.LGBM_BoosterGetEvalNames(
self.handle,
ctypes.byref(tmp_out_len),
ptr_string_buffers))
if self.__num_inner_eval != tmp_out_len.value:
raise ValueError("Length of eval names doesn't equal with num_evals")
self.__name_inner_eval = \
[string_buffers[i].value.decode() for i in range_(self.__num_inner_eval)]
self.__higher_better_inner_eval = \
[name.startswith(('auc', 'ndcg')) for name in self.__name_inner_eval]
def attr(self, key):
"""
Get attribute string from the Booster.
Parameters
----------
key : str
The key to get attribute from.
Returns
-------
value : str
The attribute value of the key, returns None if attribute do not exist.
"""
return self.__attr.get(key, None)
def set_attr(self, **kwargs):
"""
Set the attribute of the Booster.
Parameters
----------
**kwargs
The attributes to set. Setting a value to None deletes an attribute.
"""
for key, value in kwargs.items():
if value is not None:
if not isinstance(value, string_type):
raise ValueError("Set attr only accepts strings")
self.__attr[key] = value
else:
self.__attr.pop(key, None)
| cbecker/LightGBM | python-package/lightgbm/basic.py | Python | mit | 66,093 | 0.001407 |
"""Convert "arbitrary" sound files to AIFF (Apple and SGI's audio format).
Input may be compressed.
Uncompressed file type may be AIFF, WAV, VOC, 8SVX, NeXT/Sun, and others.
An exception is raised if the file is not of a recognized type.
Returned filename is either the input filename or a temporary filename;
in the latter case the caller must ensure that it is removed.
Other temporary files used are removed by the function.
"""
import os
import tempfile
import pipes
import sndhdr
__all__ = ["error", "toaiff"]
table = {}
t = pipes.Template()
t.append('sox -t au - -t aiff -r 8000 -', '--')
table['au'] = t
# XXX The following is actually sub-optimal.
# XXX The HCOM sampling rate can be 22k, 22k/2, 22k/3 or 22k/4.
# XXX We must force the output sampling rate else the SGI won't play
# XXX files sampled at 5.5k or 7.333k; however this means that files
# XXX sampled at 11k are unnecessarily expanded.
# XXX Similar comments apply to some other file types.
t = pipes.Template()
t.append('sox -t hcom - -t aiff -r 22050 -', '--')
table['hcom'] = t
t = pipes.Template()
t.append('sox -t voc - -t aiff -r 11025 -', '--')
table['voc'] = t
t = pipes.Template()
t.append('sox -t wav - -t aiff -', '--')
table['wav'] = t
t = pipes.Template()
t.append('sox -t 8svx - -t aiff -r 16000 -', '--')
table['8svx'] = t
t = pipes.Template()
t.append('sox -t sndt - -t aiff -r 16000 -', '--')
table['sndt'] = t
t = pipes.Template()
t.append('sox -t sndr - -t aiff -r 16000 -', '--')
table['sndr'] = t
uncompress = pipes.Template()
uncompress.append('uncompress', '--')
class error(Exception):
pass
def toaiff(filename):
temps = []
ret = None
try:
ret = _toaiff(filename, temps)
finally:
for temp in temps[:]:
if temp != ret:
try:
os.unlink(temp)
except os.error:
pass
temps.remove(temp)
return ret
def _toaiff(filename, temps):
if filename[-2:] == '.Z':
fname = tempfile.mktemp()
temps.append(fname)
sts = uncompress.copy(filename, fname)
if sts:
raise error, filename + ': uncompress failed'
else:
fname = filename
try:
ftype = sndhdr.whathdr(fname)
if ftype:
ftype = ftype[0] # All we're interested in
except IOError, msg:
if type(msg) == type(()) and len(msg) == 2 and \
type(msg[0]) == type(0) and type(msg[1]) == type(''):
msg = msg[1]
if type(msg) != type(''):
msg = `msg`
raise error, filename + ': ' + msg
if ftype == 'aiff':
return fname
if ftype is None or not table.has_key(ftype):
raise error, \
filename + ': unsupported audio file type ' + `ftype`
temp = tempfile.mktemp()
temps.append(temp)
sts = table[ftype].copy(fname, temp)
if sts:
raise error, filename + ': conversion to aiff failed'
return temp
| MalloyPower/parsing-python | front-end/testsuite-python-lib/Python-2.2/Lib/toaiff.py | Python | mit | 2,989 | 0.004015 |
# -*- coding: utf-8 -*-
""" S3 Query Construction
@copyright: 2009-2015 (c) Sahana Software Foundation
@license: MIT
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
"""
__all__ = ("FS",
"S3FieldSelector",
"S3Joins",
"S3ResourceField",
"S3ResourceQuery",
"S3URLQuery",
"S3URLQueryParser",
)
import datetime
import re
import sys
from gluon import current
from gluon.storage import Storage
from s3dal import Field, Row
from s3fields import S3RepresentLazy
from s3utils import s3_get_foreign_key, s3_unicode, S3TypeConverter
ogetattr = object.__getattribute__
TEXTTYPES = ("string", "text")
# =============================================================================
class S3FieldSelector(object):
""" Helper class to construct a resource query """
LOWER = "lower"
UPPER = "upper"
OPERATORS = [LOWER, UPPER]
def __init__(self, name, type=None):
""" Constructor """
if not isinstance(name, basestring) or not name:
raise SyntaxError("name required")
self.name = str(name)
self.type = type
self.op = None
# -------------------------------------------------------------------------
def __lt__(self, value):
return S3ResourceQuery(S3ResourceQuery.LT, self, value)
# -------------------------------------------------------------------------
def __le__(self, value):
return S3ResourceQuery(S3ResourceQuery.LE, self, value)
# -------------------------------------------------------------------------
def __eq__(self, value):
return S3ResourceQuery(S3ResourceQuery.EQ, self, value)
# -------------------------------------------------------------------------
def __ne__(self, value):
return S3ResourceQuery(S3ResourceQuery.NE, self, value)
# -------------------------------------------------------------------------
def __ge__(self, value):
return S3ResourceQuery(S3ResourceQuery.GE, self, value)
# -------------------------------------------------------------------------
def __gt__(self, value):
return S3ResourceQuery(S3ResourceQuery.GT, self, value)
# -------------------------------------------------------------------------
def like(self, value):
return S3ResourceQuery(S3ResourceQuery.LIKE, self, value)
# -------------------------------------------------------------------------
def belongs(self, value):
return S3ResourceQuery(S3ResourceQuery.BELONGS, self, value)
# -------------------------------------------------------------------------
def contains(self, value):
return S3ResourceQuery(S3ResourceQuery.CONTAINS, self, value)
# -------------------------------------------------------------------------
def anyof(self, value):
return S3ResourceQuery(S3ResourceQuery.ANYOF, self, value)
# -------------------------------------------------------------------------
def typeof(self, value):
return S3ResourceQuery(S3ResourceQuery.TYPEOF, self, value)
# -------------------------------------------------------------------------
def lower(self):
self.op = self.LOWER
return self
# -------------------------------------------------------------------------
def upper(self):
self.op = self.UPPER
return self
# -------------------------------------------------------------------------
def expr(self, val):
if self.op and val is not None:
if self.op == self.LOWER and \
hasattr(val, "lower") and callable(val.lower) and \
(not isinstance(val, Field) or val.type in TEXTTYPES):
return val.lower()
elif self.op == self.UPPER and \
hasattr(val, "upper") and callable(val.upper) and \
(not isinstance(val, Field) or val.type in TEXTTYPES):
return val.upper()
return val
# -------------------------------------------------------------------------
def represent(self, resource):
try:
rfield = S3ResourceField(resource, self.name)
except:
colname = None
else:
colname = rfield.colname
if colname:
if self.op is not None:
return "%s.%s()" % (colname, self.op)
else:
return colname
else:
return "(%s?)" % self.name
# -------------------------------------------------------------------------
@classmethod
def extract(cls, resource, row, field):
"""
Extract a value from a Row
@param resource: the resource
@param row: the Row
@param field: the field
@return: field if field is not a Field/S3FieldSelector instance,
the value from the row otherwise
"""
error = lambda fn: KeyError("Field not found: %s" % fn)
t = type(field)
if isinstance(field, Field):
colname = str(field)
tname, fname = colname.split(".", 1)
elif t is S3FieldSelector:
rfield = S3ResourceField(resource, field.name)
colname = rfield.colname
if not colname:
# unresolvable selector
raise error(field.name)
fname = rfield.fname
tname = rfield.tname
elif t is S3ResourceField:
colname = field.colname
if not colname:
# unresolved selector
return None
fname = field.fname
tname = field.tname
else:
return field
if type(row) is Row:
try:
if tname in row.__dict__:
value = ogetattr(ogetattr(row, tname), fname)
else:
value = ogetattr(row, fname)
except:
try:
value = row[colname]
except (KeyError, AttributeError):
raise error(colname)
elif fname in row:
value = row[fname]
elif colname in row:
value = row[colname]
elif tname is not None and \
tname in row and fname in row[tname]:
value = row[tname][fname]
else:
raise error(colname)
if callable(value):
# Lazy virtual field
try:
value = value()
except:
current.log.error(sys.exc_info()[1])
value = None
if hasattr(field, "expr"):
return field.expr(value)
return value
# -------------------------------------------------------------------------
def resolve(self, resource):
"""
Resolve this field against a resource
@param resource: the resource
"""
return S3ResourceField(resource, self.name)
# =============================================================================
# Short name for the S3FieldSelector class
#
FS = S3FieldSelector
# =============================================================================
class S3FieldPath(object):
""" Helper class to parse field selectors """
# -------------------------------------------------------------------------
@classmethod
def resolve(cls, resource, selector, tail=None):
"""
Resolve a selector (=field path) against a resource
@param resource: the S3Resource to resolve against
@param selector: the field selector string
@param tail: tokens to append to the selector
The general syntax for a selector is:
selector = {[alias].}{[key]$}[field|selector]
(Parts in {} are optional, | indicates alternatives)
* Alias can be:
~ refers to the resource addressed by the
preceding parts of the selector (=last
resource)
component alias of a component of the last resource
linktable alias of a link table of the last resource
table name of a table that has a foreign key for
the last resource (auto-detect the key)
key:table same as above, but specifying the foreign key
* Key can be:
key the name of a foreign key in the last resource
context a context expression
* Field can be:
fieldname the name of a field or virtual field of the
last resource
context a context expression
A "context expression" is a name enclosed in parentheses:
(context)
During parsing, context expressions get replaced by the
string which has been configured for this name for the
last resource with:
s3db.configure(tablename, context = dict(name = "string"))
With context expressions, the same selector can be used
for different resources, each time resolving into the
specific field path. However, the field addressed must
be of the same type in all resources to form valid
queries.
If a context name can not be resolved, resolve() will
still succeed - but the S3FieldPath returned will have
colname=None and ftype="context" (=unresolvable context).
"""
if not selector:
raise SyntaxError("Invalid selector: %s" % selector)
tokens = re.split("(\.|\$)", selector)
if tail:
tokens.extend(tail)
parser = cls(resource, None, tokens)
parser.original = selector
return parser
# -------------------------------------------------------------------------
def __init__(self, resource, table, tokens):
"""
Constructor - not to be called directly, use resolve() instead
@param resource: the S3Resource
@param table: the table
@param tokens: the tokens as list
"""
s3db = current.s3db
if table is None:
table = resource.table
# Initialize
self.original = None
self.tname = table._tablename
self.fname = None
self.field = None
self.ftype = None
self.virtual = False
self.colname = None
self.joins = {}
self.distinct = False
self.multiple = True
head = tokens.pop(0)
tail = None
if head and head[0] == "(" and head[-1] == ")":
# Context expression
head = head.strip("()")
self.fname = head
self.ftype = "context"
if not resource:
resource = s3db.resource(table, components=[])
context = resource.get_config("context")
if context and head in context:
tail = self.resolve(resource, context[head], tail=tokens)
else:
# unresolvable
pass
elif tokens:
# Resolve the tail
op = tokens.pop(0)
if tokens:
if op == ".":
# head is a component or linktable alias, and tokens is
# a field expression in the component/linked table
if not resource:
resource = s3db.resource(table, components=[])
ktable, join, m, d = self._resolve_alias(resource, head)
self.multiple = m
self.distinct = d
else:
# head is a foreign key in the current table and tokens is
# a field expression in the referenced table
ktable, join = self._resolve_key(table, head)
self.distinct = True
if join is not None:
self.joins[ktable._tablename] = join
tail = S3FieldPath(None, ktable, tokens)
else:
raise SyntaxError("trailing operator")
if tail is None:
# End of the expression
if self.ftype != "context":
# Expression is resolved, head is a field name:
self.field = self._resolve_field(table, head)
if not self.field:
self.virtual = True
self.ftype = "virtual"
else:
self.virtual = False
self.ftype = str(self.field.type)
self.fname = head
self.colname = "%s.%s" % (self.tname, self.fname)
else:
# Read field data from tail
self.tname = tail.tname
self.fname = tail.fname
self.field = tail.field
self.ftype = tail.ftype
self.virtual = tail.virtual
self.colname = tail.colname
self.distinct |= tail.distinct
self.multiple |= tail.multiple
self.joins.update(tail.joins)
# -------------------------------------------------------------------------
@staticmethod
def _resolve_field(table, fieldname):
"""
Resolve a field name against the table, recognizes "id" as
table._id.name, and "uid" as current.xml.UID.
@param table: the Table
@param fieldname: the field name
@return: the Field
"""
if fieldname == "uid":
fieldname = current.xml.UID
if fieldname == "id":
field = table._id
elif fieldname in table.fields:
field = ogetattr(table, fieldname)
else:
field = None
return field
# -------------------------------------------------------------------------
@staticmethod
def _resolve_key(table, fieldname):
"""
Resolve a foreign key into the referenced table and the
join and left join between the current table and the
referenced table
@param table: the current Table
@param fieldname: the fieldname of the foreign key
@return: tuple of (referenced table, join, left join)
@raise: AttributeError is either the field or
the referended table are not found
@raise: SyntaxError if the field is not a foreign key
"""
if fieldname in table.fields:
f = table[fieldname]
else:
raise AttributeError("key not found: %s" % fieldname)
ktablename, pkey, multiple = s3_get_foreign_key(f, m2m=False)
if not ktablename:
raise SyntaxError("%s is not a foreign key" % f)
ktable = current.s3db.table(ktablename,
AttributeError("undefined table %s" % ktablename),
db_only=True)
pkey = ktable[pkey] if pkey else ktable._id
join = [ktable.on(f == pkey)]
return ktable, join
# -------------------------------------------------------------------------
@staticmethod
def _resolve_alias(resource, alias):
"""
Resolve a table alias into the linked table (component, linktable
or free join), and the joins and left joins between the current
resource and the linked table.
@param resource: the current S3Resource
@param alias: the alias
@return: tuple of (linked table, joins, left joins, multiple,
distinct), the two latter being flags to indicate
possible ambiguous query results (needed by the query
builder)
@raise: AttributeError if one of the key fields or tables
can not be found
@raise: SyntaxError if the alias can not be resolved (e.g.
because on of the keys isn't a foreign key, points
to the wrong table or is ambiguous)
"""
# Alias for this resource?
if alias in ("~", resource.alias):
return resource.table, None, False, False
multiple = True
linked = resource.linked
if linked and linked.alias == alias:
# It's the linked table
linktable = resource.table
ktable = linked.table
join = [ktable.on(ktable[linked.fkey] == linktable[linked.rkey])]
return ktable, join, multiple, True
s3db = current.s3db
tablename = resource.tablename
# Try to attach the component
if alias not in resource.components and \
alias not in resource.links:
_alias = alias
hook = s3db.get_component(tablename, alias)
if not hook:
_alias = s3db.get_alias(tablename, alias)
if _alias:
hook = s3db.get_component(tablename, _alias)
if hook:
resource._attach(_alias, hook)
components = resource.components
links = resource.links
if alias in components:
# Is a component
component = components[alias]
ktable = component.table
join = component._join()
multiple = component.multiple
elif alias in links:
# Is a linktable
link = links[alias]
ktable = link.table
join = link._join()
elif "_" in alias:
# Is a free join
DELETED = current.xml.DELETED
table = resource.table
tablename = resource.tablename
pkey = fkey = None
# Find the table
fkey, kname = (alias.split(":") + [None])[:2]
if not kname:
fkey, kname = kname, fkey
ktable = s3db.table(kname,
AttributeError("table not found: %s" % kname),
db_only=True)
if fkey is None:
# Autodetect left key
for fname in ktable.fields:
tn, key, m = s3_get_foreign_key(ktable[fname], m2m=False)
if not tn:
continue
if tn == tablename:
if fkey is not None:
raise SyntaxError("ambiguous foreign key in %s" %
alias)
else:
fkey = fname
if key:
pkey = key
if fkey is None:
raise SyntaxError("no foreign key for %s in %s" %
(tablename, kname))
else:
# Check left key
if fkey not in ktable.fields:
raise AttributeError("no field %s in %s" % (fkey, kname))
tn, pkey, m = s3_get_foreign_key(ktable[fkey], m2m=False)
if tn and tn != tablename:
raise SyntaxError("%s.%s is not a foreign key for %s" %
(kname, fkey, tablename))
elif not tn:
raise SyntaxError("%s.%s is not a foreign key" %
(kname, fkey))
# Default primary key
if pkey is None:
pkey = table._id.name
# Build join
query = (table[pkey] == ktable[fkey])
if DELETED in ktable.fields:
query &= ktable[DELETED] != True
join = [ktable.on(query)]
else:
raise SyntaxError("Invalid tablename: %s" % alias)
return ktable, join, multiple, True
# =============================================================================
class S3ResourceField(object):
""" Helper class to resolve a field selector against a resource """
# -------------------------------------------------------------------------
def __init__(self, resource, selector, label=None):
"""
Constructor
@param resource: the resource
@param selector: the field selector (string)
"""
self.resource = resource
self.selector = selector
lf = S3FieldPath.resolve(resource, selector)
self.tname = lf.tname
self.fname = lf.fname
self.colname = lf.colname
self._joins = lf.joins
self.distinct = lf.distinct
self.multiple = lf.multiple
self._join = None
self.field = lf.field
self.virtual = False
self.represent = s3_unicode
self.requires = None
if self.field is not None:
field = self.field
self.ftype = str(field.type)
if resource.linked is not None and self.ftype == "id":
# Always represent the link-table's ID as the
# linked record's ID => needed for data tables
self.represent = lambda i, resource=resource: \
resource.component_id(None, i)
else:
self.represent = field.represent
self.requires = field.requires
elif self.colname:
self.virtual = True
self.ftype = "virtual"
else:
self.ftype = "context"
# Fall back to the field label
if label is None:
fname = self.fname
if fname in ["L1", "L2", "L3", "L3", "L4", "L5"]:
try:
label = current.gis.get_location_hierarchy(fname)
except:
label = None
elif fname == "L0":
label = current.messages.COUNTRY
if label is None:
f = self.field
if f:
label = f.label
elif fname:
label = " ".join([s.strip().capitalize()
for s in fname.split("_") if s])
else:
label = None
self.label = label
self.show = True
# -------------------------------------------------------------------------
def __repr__(self):
""" String representation of this instance """
return "<S3ResourceField " \
"selector='%s' " \
"label='%s' " \
"table='%s' " \
"field='%s' " \
"type='%s'>" % \
(self.selector, self.label, self.tname, self.fname, self.ftype)
# -------------------------------------------------------------------------
@property
def join(self):
"""
Implicit join (Query) for this field, for backwards-compatibility
"""
if self._join is not None:
return self._join
join = self._join = {}
for tablename, joins in self._joins.items():
query = None
for expression in joins:
if query is None:
query = expression.second
else:
query &= expression.second
if query:
join[tablename] = query
return join
# -------------------------------------------------------------------------
@property
def left(self):
"""
The left joins for this field, for backwards-compability
"""
return self._joins
# -------------------------------------------------------------------------
def extract(self, row, represent=False, lazy=False):
"""
Extract the value for this field from a row
@param row: the Row
@param represent: render a text representation for the value
@param lazy: return a lazy representation handle if available
"""
tname = self.tname
fname = self.fname
colname = self.colname
error = "Field not found in Row: %s" % colname
if type(row) is Row:
try:
if tname in row.__dict__:
value = ogetattr(ogetattr(row, tname), fname)
else:
value = ogetattr(row, fname)
except:
try:
value = row[colname]
except (KeyError, AttributeError):
raise KeyError(error)
elif fname in row:
value = row[fname]
elif colname in row:
value = row[colname]
elif tname is not None and \
tname in row and fname in row[tname]:
value = row[tname][fname]
else:
raise KeyError(error)
if callable(value):
# Lazy virtual field
try:
value = value()
except:
current.log.error(sys.exc_info()[1])
value = None
if represent:
renderer = self.represent
if callable(renderer):
if lazy and hasattr(renderer, "bulk"):
return S3RepresentLazy(value, renderer)
else:
return renderer(value)
else:
return s3_unicode(value)
else:
return value
# =============================================================================
class S3Joins(object):
""" A collection of joins """
def __init__(self, tablename, joins=None):
"""
Constructor
@param tablename: the name of the master table
@param joins: list of joins
"""
self.tablename = tablename
self.joins = {}
self.tables = set()
self.add(joins)
# -------------------------------------------------------------------------
def __iter__(self):
"""
Iterate over the names of all joined tables in the collection
"""
return self.joins.__iter__()
# -------------------------------------------------------------------------
def __getitem__(self, tablename):
"""
Get the list of joins for a table
@param tablename: the tablename
"""
return self.joins.__getitem__(tablename)
# -------------------------------------------------------------------------
def __setitem__(self, tablename, joins):
"""
Update the joins for a table
@param tablename: the tablename
@param joins: the list of joins for this table
"""
master = self.tablename
joins_dict = self.joins
tables = current.db._adapter.tables
joins_dict[tablename] = joins
if len(joins) > 1:
for join in joins:
try:
tname = join.first._tablename
except AttributeError:
tname = str(join.first)
if tname not in joins_dict and \
master in tables(join.second):
joins_dict[tname] = [join]
self.tables.add(tablename)
return
# -------------------------------------------------------------------------
def keys(self):
"""
Get a list of names of all joined tables
"""
return self.joins.keys()
# -------------------------------------------------------------------------
def items(self):
"""
Get a list of tuples (tablename, [joins]) for all joined tables
"""
return self.joins.items()
# -------------------------------------------------------------------------
def values(self):
"""
Get a list of joins for all joined tables
@return: a nested list like [[join, join, ...], ...]
"""
return self.joins.values()
# -------------------------------------------------------------------------
def add(self, joins):
"""
Add joins to this collection
@param joins: a join or a list/tuple of joins
@return: the list of names of all tables for which joins have
been added to the collection
"""
tablenames = set()
if joins:
if not isinstance(joins, (list, tuple)):
joins = [joins]
for join in joins:
tablename = join.first._tablename
self[tablename] = [join]
tablenames.add(tablename)
return list(tablenames)
# -------------------------------------------------------------------------
def extend(self, other):
"""
Extend this collection with the joins from another collection
@param other: the other collection (S3Joins), or a dict like
{tablename: [join, join]}
@return: the list of names of all tables for which joins have
been added to the collection
"""
if type(other) is S3Joins:
add = self.tables.add
else:
add = None
joins = self.joins if type(other) is S3Joins else self
for tablename in other:
if tablename not in self.joins:
joins[tablename] = other[tablename]
if add:
add(tablename)
return other.keys()
# -------------------------------------------------------------------------
def __repr__(self):
"""
String representation of this collection
"""
return "<S3Joins %s>" % str([str(j) for j in self.as_list()])
# -------------------------------------------------------------------------
def as_list(self, tablenames=None, aqueries=None, prefer=None):
"""
Return joins from this collection as list
@param tablenames: the names of the tables for which joins
shall be returned, defaults to all tables
in the collection. Dependencies will be
included automatically (if available)
@param aqueries: dict of accessible-queries {tablename: query}
to include in the joins; if there is no entry
for a particular table, then it will be looked
up from current.auth and added to the dict.
To prevent differential authorization of a
particular joined table, set {<tablename>: None}
in the dict
@param prefer: If any table or any of its dependencies would be
joined by this S3Joins collection, then skip this
table here (and enforce it to be joined by the
preferred collection), to prevent duplication of
left joins as inner joins:
join = inner_joins.as_list(prefer=left_joins)
left = left_joins.as_list()
@return: a list of joins, ordered by their interdependency, which
can be used as join/left parameter of Set.select()
"""
accessible_query = current.auth.s3_accessible_query
if tablenames is None:
tablenames = self.tables
else:
tablenames = set(tablenames)
skip = set()
if prefer:
preferred_joins = prefer.as_list(tablenames=tablenames)
for join in preferred_joins:
try:
tname = join.first._tablename
except AttributeError:
tname = str(join.first)
skip.add(tname)
tablenames -= skip
joins = self.joins
# Resolve dependencies
required_tables = set()
get_tables = current.db._adapter.tables
for tablename in tablenames:
if tablename not in joins or \
tablename == self.tablename or \
tablename in skip:
continue
join_list = joins[tablename]
preferred = False
dependencies = set()
for join in join_list:
join_tables = set(get_tables(join.second))
if join_tables:
if any((tname in skip for tname in join_tables)):
preferred = True
dependencies |= join_tables
if preferred:
skip.add(tablename)
skip |= dependencies
prefer.extend({tablename: join_list})
else:
required_tables.add(tablename)
required_tables |= dependencies
# Collect joins
joins_dict = {}
for tablename in required_tables:
if tablename not in joins or tablename == self.tablename:
continue
for join in joins[tablename]:
j = join
table = j.first
tname = table._tablename
if aqueries is not None and tname in tablenames:
if tname not in aqueries:
aquery = accessible_query("read", table)
aqueries[tname] = aquery
else:
aquery = aqueries[tname]
if aquery is not None:
j = join.first.on(join.second & aquery)
joins_dict[tname] = j
# Sort joins (if possible)
try:
return self.sort(joins_dict.values())
except RuntimeError:
return joins_dict.values()
# -------------------------------------------------------------------------
@classmethod
def sort(cls, joins):
"""
Sort a list of left-joins by their interdependency
@param joins: the list of joins
"""
if len(joins) <= 1:
return joins
r = list(joins)
tables = current.db._adapter.tables
append = r.append
head = None
for i in xrange(len(joins)):
join = r.pop(0)
head = join
tablenames = tables(join.second)
for j in r:
try:
tn = j.first._tablename
except AttributeError:
tn = str(j.first)
if tn in tablenames:
head = None
break
if head is not None:
break
else:
append(join)
if head is not None:
return [head] + cls.sort(r)
else:
raise RuntimeError("circular join dependency")
# =============================================================================
class S3ResourceQuery(object):
"""
Helper class representing a resource query
- unlike DAL Query objects, these can be converted to/from URL filters
"""
# Supported operators
NOT = "not"
AND = "and"
OR = "or"
LT = "lt"
LE = "le"
EQ = "eq"
NE = "ne"
GE = "ge"
GT = "gt"
LIKE = "like"
BELONGS = "belongs"
CONTAINS = "contains"
ANYOF = "anyof"
TYPEOF = "typeof"
COMPARISON = [LT, LE, EQ, NE, GE, GT,
LIKE, BELONGS, CONTAINS, ANYOF, TYPEOF]
OPERATORS = [NOT, AND, OR] + COMPARISON
# -------------------------------------------------------------------------
def __init__(self, op, left=None, right=None):
""" Constructor """
if op not in self.OPERATORS:
raise SyntaxError("Invalid operator: %s" % op)
self.op = op
self.left = left
self.right = right
# -------------------------------------------------------------------------
def __and__(self, other):
""" AND """
return S3ResourceQuery(self.AND, self, other)
# -------------------------------------------------------------------------
def __or__(self, other):
""" OR """
return S3ResourceQuery(self.OR, self, other)
# -------------------------------------------------------------------------
def __invert__(self):
""" NOT """
if self.op == self.NOT:
return self.left
else:
return S3ResourceQuery(self.NOT, self)
# -------------------------------------------------------------------------
def _joins(self, resource, left=False):
op = self.op
l = self.left
r = self.right
if op in (self.AND, self.OR):
if isinstance(l, S3ResourceQuery):
ljoins, ld = l._joins(resource, left=left)
else:
ljoins, ld = {}, False
if isinstance(r, S3ResourceQuery):
rjoins, rd = r._joins(resource, left=left)
else:
rjoins, rd = {}, False
ljoins = dict(ljoins)
ljoins.update(rjoins)
return (ljoins, ld or rd)
elif op == self.NOT:
if isinstance(l, S3ResourceQuery):
return l._joins(resource, left=left)
else:
return {}, False
joins, distinct = {}, False
if isinstance(l, S3FieldSelector):
try:
rfield = l.resolve(resource)
except (SyntaxError, AttributeError):
pass
else:
distinct = rfield.distinct
if distinct and left or not distinct and not left:
joins = rfield._joins
return (joins, distinct)
# -------------------------------------------------------------------------
def fields(self):
""" Get all field selectors involved with this query """
op = self.op
l = self.left
r = self.right
if op in (self.AND, self.OR):
lf = l.fields()
rf = r.fields()
return lf + rf
elif op == self.NOT:
return l.fields()
elif isinstance(l, S3FieldSelector):
return [l.name]
else:
return []
# -------------------------------------------------------------------------
def split(self, resource):
"""
Split this query into a real query and a virtual one (AND)
@param resource: the S3Resource
@return: tuple (DAL-translatable sub-query, virtual filter),
both S3ResourceQuery instances
"""
op = self.op
l = self.left
r = self.right
if op == self.AND:
lq, lf = l.split(resource) \
if isinstance(l, S3ResourceQuery) else (l, None)
rq, rf = r.split(resource) \
if isinstance(r, S3ResourceQuery) else (r, None)
q = lq
if rq is not None:
if q is not None:
q &= rq
else:
q = rq
f = lf
if rf is not None:
if f is not None:
f &= rf
else:
f = rf
return q, f
elif op == self.OR:
lq, lf = l.split(resource) \
if isinstance(l, S3ResourceQuery) else (l, None)
rq, rf = r.split(resource) \
if isinstance(r, S3ResourceQuery) else (r, None)
if lf is not None or rf is not None:
return None, self
else:
q = lq
if rq is not None:
if q is not None:
q |= rq
else:
q = rq
return q, None
elif op == self.NOT:
if isinstance(l, S3ResourceQuery):
if l.op == self.OR:
i = (~(l.left)) & (~(l.right))
return i.split(resource)
else:
q, f = l.split(resource)
if q is not None and f is not None:
return None, self
elif q is not None:
return ~q, None
elif f is not None:
return None, ~f
else:
return ~l, None
l = self.left
try:
if isinstance(l, S3FieldSelector):
lfield = l.resolve(resource)
else:
lfield = S3ResourceField(resource, l)
except:
lfield = None
if not lfield or lfield.field is None:
return None, self
else:
return self, None
# -------------------------------------------------------------------------
def transform(self, resource):
"""
Placeholder for transformation method
@param resource: the S3Resource
"""
# @todo: implement
return self
# -------------------------------------------------------------------------
def query(self, resource):
"""
Convert this S3ResourceQuery into a DAL query, ignoring virtual
fields (the necessary joins for this query can be constructed
with the joins() method)
@param resource: the resource to resolve the query against
"""
op = self.op
l = self.left
r = self.right
# Resolve query components
if op == self.AND:
l = l.query(resource) if isinstance(l, S3ResourceQuery) else l
r = r.query(resource) if isinstance(r, S3ResourceQuery) else r
if l is None or r is None:
return None
elif l is False or r is False:
return l if r is False else r if l is False else False
else:
return l & r
elif op == self.OR:
l = l.query(resource) if isinstance(l, S3ResourceQuery) else l
r = r.query(resource) if isinstance(r, S3ResourceQuery) else r
if l is None or r is None:
return None
elif l is False or r is False:
return l if r is False else r if l is False else False
else:
return l | r
elif op == self.NOT:
l = l.query(resource) if isinstance(l, S3ResourceQuery) else l
if l is None:
return None
elif l is False:
return False
else:
return ~l
# Resolve the fields
if isinstance(l, S3FieldSelector):
try:
rfield = S3ResourceField(resource, l.name)
except:
return None
if rfield.virtual:
return None
elif not rfield.field:
return False
lfield = l.expr(rfield.field)
elif isinstance(l, Field):
lfield = l
else:
return None # not a field at all
if isinstance(r, S3FieldSelector):
try:
rfield = S3ResourceField(resource, r.name)
except:
return None
rfield = rfield.field
if rfield.virtual:
return None
elif not rfield.field:
return False
rfield = r.expr(rfield.field)
else:
rfield = r
# Resolve the operator
invert = False
query_bare = self._query_bare
ftype = str(lfield.type)
if isinstance(rfield, (list, tuple)) and ftype[:4] != "list":
if op == self.EQ:
op = self.BELONGS
elif op == self.NE:
op = self.BELONGS
invert = True
elif op not in (self.BELONGS, self.TYPEOF):
query = None
for v in rfield:
q = query_bare(op, lfield, v)
if q is not None:
if query is None:
query = q
else:
query |= q
return query
# Convert date(time) strings
if ftype == "datetime" and \
isinstance(rfield, basestring):
rfield = S3TypeConverter.convert(datetime.datetime, rfield)
elif ftype == "date" and \
isinstance(rfield, basestring):
rfield = S3TypeConverter.convert(datetime.date, rfield)
query = query_bare(op, lfield, rfield)
if invert:
query = ~(query)
return query
# -------------------------------------------------------------------------
def _query_bare(self, op, l, r):
"""
Translate a filter expression into a DAL query
@param op: the operator
@param l: the left operand
@param r: the right operand
"""
if op == self.CONTAINS:
q = l.contains(r, all=True)
elif op == self.ANYOF:
# NB str/int doesn't matter here
q = l.contains(r, all=False)
elif op == self.BELONGS:
q = self._query_belongs(l, r)
elif op == self.TYPEOF:
q = self._query_typeof(l, r)
elif op == self.LIKE:
q = l.like(s3_unicode(r))
elif op == self.LT:
q = l < r
elif op == self.LE:
q = l <= r
elif op == self.EQ:
q = l == r
elif op == self.NE:
q = l != r
elif op == self.GE:
q = l >= r
elif op == self.GT:
q = l > r
else:
q = None
return q
# -------------------------------------------------------------------------
def _query_typeof(self, l, r):
"""
Translate TYPEOF into DAL expression
@param l: the left operator
@param r: the right operator
"""
hierarchy, field, nodeset, none = self._resolve_hierarchy(l, r)
if not hierarchy:
# Not a hierarchical query => use simple belongs
return self._query_belongs(l, r)
if not field:
# Field does not exist (=>skip subquery)
return None
# Construct the subquery
list_type = str(field.type)[:5] == "list:"
if nodeset:
if list_type:
q = (field.contains(list(nodeset)))
elif len(nodeset) > 1:
q = (field.belongs(nodeset))
else:
q = (field == tuple(nodeset)[0])
else:
q = None
if none:
# None needs special handling with older DAL versions
if not list_type:
if q is None:
q = (field == None)
else:
q |= (field == None)
if q is None:
# Values not resolvable (=subquery always fails)
q = field.belongs(set())
return q
# -------------------------------------------------------------------------
@classmethod
def _resolve_hierarchy(cls, l, r):
"""
Resolve the hierarchical lookup in a typeof-query
@param l: the left operator
@param r: the right operator
"""
from s3hierarchy import S3Hierarchy
tablename = l.tablename
# Connect to the hierarchy
hierarchy = S3Hierarchy(tablename)
if hierarchy.config is None:
# Reference to a hierarchical table?
ktablename, key = s3_get_foreign_key(l)[:2]
if ktablename:
hierarchy = S3Hierarchy(ktablename)
else:
key = None
list_type = str(l.type)[:5] == "list:"
if hierarchy.config is None and not list_type:
# No hierarchy configured and no list:reference
return False, None, None, None
field, keys = l, r
if not key:
s3db = current.s3db
table = s3db[tablename]
if l.name != table._id.name:
# Lookup-field rather than primary key => resolve it
# Build a filter expression for the lookup table
fs = S3FieldSelector(l.name)
if list_type:
expr = fs.contains(r)
else:
expr = cls._query_belongs(l, r, field = fs)
# Resolve filter expression into subquery
resource = s3db.resource(tablename)
if expr is not None:
subquery = expr.query(resource)
else:
subquery = None
if not subquery:
# Field doesn't exist
return True, None, None, None
# Execute query and retrieve the lookup table IDs
DELETED = current.xml.DELETED
if DELETED in table.fields:
subquery &= table[DELETED] != True
rows = current.db(subquery).select(table._id)
# Override field/keys
field = table[hierarchy.pkey.name]
keys = set([row[table._id.name] for row in rows])
nodeset, none = None, False
if keys:
# Lookup all descendant types from the hierarchy
none = False
if not isinstance(keys, (list, tuple, set)):
keys = set([keys])
nodes = set()
for node in keys:
if node is None:
none = True
else:
try:
node_id = long(node)
except ValueError:
continue
nodes.add(node_id)
if hierarchy.config is not None:
nodeset = hierarchy.findall(nodes, inclusive=True)
else:
nodeset = nodes
elif keys is None:
none = True
return True, field, nodeset, none
# -------------------------------------------------------------------------
@staticmethod
def _query_belongs(l, r, field=None):
"""
Resolve BELONGS into a DAL expression (or S3ResourceQuery if
field is an S3FieldSelector)
@param l: the left operator
@param r: the right operator
@param field: alternative left operator
"""
if field is None:
field = l
expr = None
none = False
if not isinstance(r, (list, tuple, set)):
items = [r]
else:
items = r
if None in items:
none = True
items = [item for item in items if item is not None]
wildcard = False
if str(l.type) in ("string", "text"):
for item in items:
if isinstance(item, basestring):
if "*" in item and "%" not in item:
s = item.replace("*", "%")
else:
s = item
else:
try:
s = str(item)
except:
continue
if "%" in s:
wildcard = True
_expr = (field.like(s))
else:
_expr = (field == s)
if expr is None:
expr = _expr
else:
expr |= _expr
if not wildcard:
if len(items) == 1:
# Don't use belongs() for single value
expr = (field == tuple(items)[0])
elif items:
expr = (field.belongs(items))
if none:
# None needs special handling with older DAL versions
if expr is None:
expr = (field == None)
else:
expr |= (field == None)
elif expr is None:
expr = field.belongs(set())
return expr
# -------------------------------------------------------------------------
def __call__(self, resource, row, virtual=True):
"""
Probe whether the row matches the query
@param resource: the resource to resolve the query against
@param row: the DB row
@param virtual: execute only virtual queries
"""
if self.op == self.AND:
l = self.left(resource, row, virtual=False)
r = self.right(resource, row, virtual=False)
if l is None:
return r
if r is None:
return l
return l and r
elif self.op == self.OR:
l = self.left(resource, row, virtual=False)
r = self.right(resource, row, virtual=False)
if l is None:
return r
if r is None:
return l
return l or r
elif self.op == self.NOT:
l = self.left(resource, row)
if l is None:
return None
else:
return not l
real = False
left = self.left
if isinstance(left, S3FieldSelector):
try:
lfield = left.resolve(resource)
except (AttributeError, KeyError, SyntaxError):
return None
if lfield.field is not None:
real = True
elif not lfield.virtual:
# Unresolvable expression => skip
return None
else:
lfield = left
if isinstance(left, Field):
real = True
right = self.right
if isinstance(right, S3FieldSelector):
try:
rfield = right.resolve(resource)
except (AttributeError, KeyError, SyntaxError):
return None
if rfield.virtual:
real = False
elif rfield.field is None:
# Unresolvable expression => skip
return None
else:
rfield = right
if virtual and real:
return None
extract = lambda f: S3FieldSelector.extract(resource, row, f)
try:
l = extract(lfield)
r = extract(rfield)
except (KeyError, SyntaxError):
current.log.error(sys.exc_info()[1])
return None
if isinstance(left, S3FieldSelector):
l = left.expr(l)
if isinstance(right, S3FieldSelector):
r = right.expr(r)
op = self.op
invert = False
probe = self._probe
if isinstance(rfield, (list, tuple)) and \
not isinstance(lfield, (list, tuple)):
if op == self.EQ:
op = self.BELONGS
elif op == self.NE:
op = self.BELONGS
invert = True
elif op != self.BELONGS:
for v in r:
try:
r = probe(op, l, v)
except (TypeError, ValueError):
r = False
if r:
return True
return False
try:
r = probe(op, l, r)
except (TypeError, ValueError):
return False
if invert and r is not None:
return not r
else:
return r
# -------------------------------------------------------------------------
def _probe(self, op, l, r):
"""
Probe whether the value pair matches the query
@param l: the left value
@param r: the right value
"""
result = False
convert = S3TypeConverter.convert
# Fallbacks for TYPEOF
if op == self.TYPEOF:
if isinstance(l, (list, tuple, set)):
op = self.ANYOF
elif isinstance(r, (list, tuple, set)):
op = self.BELONGS
else:
op = self.EQ
if op == self.CONTAINS:
r = convert(l, r)
result = self._probe_contains(l, r)
elif op == self.ANYOF:
if not isinstance(r, (list, tuple, set)):
r = [r]
for v in r:
if isinstance(l, (list, tuple, set, basestring)):
if self._probe_contains(l, v):
return True
elif l == v:
return True
return False
elif op == self.BELONGS:
if not isinstance(r, (list, tuple, set)):
r = [r]
r = convert(l, r)
result = self._probe_contains(r, l)
elif op == self.LIKE:
pattern = re.escape(str(r)).replace("\\%", ".*").replace(".*.*", "\\%")
return re.match(pattern, str(l)) is not None
else:
r = convert(l, r)
if op == self.LT:
result = l < r
elif op == self.LE:
result = l <= r
elif op == self.EQ:
result = l == r
elif op == self.NE:
result = l != r
elif op == self.GE:
result = l >= r
elif op == self.GT:
result = l > r
return result
# -------------------------------------------------------------------------
@staticmethod
def _probe_contains(a, b):
"""
Probe whether a contains b
"""
if a is None:
return False
try:
if isinstance(a, basestring):
return str(b) in a
elif isinstance(a, (list, tuple, set)):
if isinstance(b, (list, tuple, set)):
convert = S3TypeConverter.convert
found = True
for _b in b:
if _b not in a:
found = False
for _a in a:
try:
if convert(_a, _b) == _a:
found = True
break
except (TypeError, ValueError):
continue
if not found:
break
return found
else:
return b in a
else:
return str(b) in str(a)
except:
return False
# -------------------------------------------------------------------------
def represent(self, resource):
"""
Represent this query as a human-readable string.
@param resource: the resource to resolve the query against
"""
op = self.op
l = self.left
r = self.right
if op == self.AND:
l = l.represent(resource) \
if isinstance(l, S3ResourceQuery) else str(l)
r = r.represent(resource) \
if isinstance(r, S3ResourceQuery) else str(r)
return "(%s and %s)" % (l, r)
elif op == self.OR:
l = l.represent(resource) \
if isinstance(l, S3ResourceQuery) else str(l)
r = r.represent(resource) \
if isinstance(r, S3ResourceQuery) else str(r)
return "(%s or %s)" % (l, r)
elif op == self.NOT:
l = l.represent(resource) \
if isinstance(l, S3ResourceQuery) else str(l)
return "(not %s)" % l
else:
if isinstance(l, S3FieldSelector):
l = l.represent(resource)
elif isinstance(l, basestring):
l = '"%s"' % l
if isinstance(r, S3FieldSelector):
r = r.represent(resource)
elif isinstance(r, basestring):
r = '"%s"' % r
if op == self.CONTAINS:
return "(%s in %s)" % (r, l)
elif op == self.BELONGS:
return "(%s in %s)" % (l, r)
elif op == self.ANYOF:
return "(%s contains any of %s)" % (l, r)
elif op == self.TYPEOF:
return "(%s is a type of %s)" % (l, r)
elif op == self.LIKE:
return "(%s like %s)" % (l, r)
elif op == self.LT:
return "(%s < %s)" % (l, r)
elif op == self.LE:
return "(%s <= %s)" % (l, r)
elif op == self.EQ:
return "(%s == %s)" % (l, r)
elif op == self.NE:
return "(%s != %s)" % (l, r)
elif op == self.GE:
return "(%s >= %s)" % (l, r)
elif op == self.GT:
return "(%s > %s)" % (l, r)
else:
return "(%s ?%s? %s)" % (l, op, r)
# -------------------------------------------------------------------------
def serialize_url(self, resource=None):
"""
Serialize this query as URL query
@return: a Storage of URL variables
"""
op = self.op
l = self.left
r = self.right
url_query = Storage()
def _serialize(n, o, v, invert):
try:
quote = lambda s: s if "," not in s else '"%s"' % s
if isinstance(v, list):
v = ",".join([quote(S3TypeConverter.convert(str, val))
for val in v])
else:
v = quote(S3TypeConverter.convert(str, v))
except:
return
if "." not in n:
if resource is not None:
n = "~.%s" % n
else:
return url_query
if o == self.LIKE:
v = v.replace("%", "*")
if o == self.EQ:
operator = ""
else:
operator = "__%s" % o
if invert:
operator = "%s!" % operator
key = "%s%s" % (n, operator)
if key in url_query:
url_query[key] = "%s,%s" % (url_query[key], v)
else:
url_query[key] = v
return url_query
if op == self.AND:
lu = l.serialize_url(resource=resource)
url_query.update(lu)
ru = r.serialize_url(resource=resource)
url_query.update(ru)
elif op == self.OR:
sub = self._or()
if sub is None:
# This OR-subtree is not serializable
return url_query
n, o, v, invert = sub
_serialize(n, o, v, invert)
elif op == self.NOT:
lu = l.serialize_url(resource=resource)
for k in lu:
url_query["%s!" % k] = lu[k]
elif isinstance(l, S3FieldSelector):
_serialize(l.name, op, r, False)
return url_query
# -------------------------------------------------------------------------
def _or(self):
"""
Helper method to URL-serialize an OR-subtree in a query in
alternative field selector syntax if they all use the same
operator and value (this is needed to URL-serialize an
S3SearchSimpleWidget query).
"""
op = self.op
l = self.left
r = self.right
if op == self.AND:
return None
elif op == self.NOT:
lname, lop, lval, linv = l._or()
return (lname, lop, lval, not linv)
elif op == self.OR:
lvars = l._or()
rvars = r._or()
if lvars is None or rvars is None:
return None
lname, lop, lval, linv = lvars
rname, rop, rval, rinv = rvars
if lop != rop or linv != rinv:
return None
if lname == rname:
return (lname, lop, [lval, rval], linv)
elif lval == rval:
return ("%s|%s" % (lname, rname), lop, lval, linv)
else:
return None
else:
return (l.name, op, r, False)
# =============================================================================
class S3URLQuery(object):
""" URL Query Parser """
# -------------------------------------------------------------------------
@classmethod
def parse(cls, resource, vars):
"""
Construct a Storage of S3ResourceQuery from a Storage of get_vars
@param resource: the S3Resource
@param vars: the get_vars
@return: Storage of S3ResourceQuery like {alias: query}, where
alias is the alias of the component the query concerns
"""
query = Storage()
if resource is None:
return query
if not vars:
return query
subquery = cls._subquery
allof = lambda l, r: l if r is None else r if l is None else r & l
for key, value in vars.iteritems():
if key == "$filter":
# Instantiate the advanced filter parser
parser = S3URLQueryParser()
if parser.parser is None:
# not available
continue
# Multiple $filter expressions?
expressions = value if type(value) is list else [value]
# Default alias (=master)
default_alias = resource.alias
# Parse all expressions
for expression in expressions:
parsed = parser.parse(expression)
for alias in parsed:
q = parsed[alias]
qalias = alias if alias is not None else default_alias
if qalias not in query:
query[qalias] = [q]
else:
query[qalias].append(q)
# Stop here
continue
elif not("." in key or key[0] == "(" and ")" in key):
# Not a filter expression
continue
# Process old-style filters
selectors, op, invert = cls.parse_expression(key)
if type(value) is list:
# Multiple queries with the same selector (AND)
q = reduce(allof,
[subquery(selectors, op, invert, v) for v in value],
None)
else:
q = subquery(selectors, op, invert, value)
if q is None:
continue
# Append to query
if len(selectors) > 1:
aliases = [s.split(".", 1)[0] for s in selectors]
if len(set(aliases)) == 1:
alias = aliases[0]
else:
alias = resource.alias
#alias = resource.alias
else:
alias = selectors[0].split(".", 1)[0]
if alias == "~":
alias = resource.alias
if alias not in query:
query[alias] = [q]
else:
query[alias].append(q)
return query
# -------------------------------------------------------------------------
@staticmethod
def parse_url(url):
"""
Parse a URL query into get_vars
@param query: the URL query string
@return: the get_vars (Storage)
"""
if not url:
return Storage()
elif "?" in url:
query = url.split("?", 1)[1]
elif "=" in url:
query = url
else:
return Storage()
import cgi
dget = cgi.parse_qsl(query, keep_blank_values=1)
get_vars = Storage()
for (key, value) in dget:
if key in get_vars:
if type(get_vars[key]) is list:
get_vars[key].append(value)
else:
get_vars[key] = [get_vars[key], value]
else:
get_vars[key] = value
return get_vars
# -------------------------------------------------------------------------
@staticmethod
def parse_expression(key):
"""
Parse a URL expression
@param key: the key for the URL variable
@return: tuple (selectors, operator, invert)
"""
if key[-1] == "!":
invert = True
else:
invert = False
fs = key.rstrip("!")
op = None
if "__" in fs:
fs, op = fs.split("__", 1)
op = op.strip("_")
if not op:
op = "eq"
if "|" in fs:
selectors = [s for s in fs.split("|") if s]
else:
selectors = [fs]
return selectors, op, invert
# -------------------------------------------------------------------------
@staticmethod
def parse_value(value):
"""
Parse a URL query value
@param value: the value
@return: the parsed value
"""
uquote = lambda w: w.replace('\\"', '\\"\\') \
.strip('"') \
.replace('\\"\\', '"')
NONE = ("NONE", "None")
if type(value) is not list:
value = [value]
vlist = []
for item in value:
w = ""
quote = False
ignore_quote = False
for c in s3_unicode(item):
if c == '"' and not ignore_quote:
w += c
quote = not quote
elif c == "," and not quote:
if w in NONE:
w = None
else:
w = uquote(w).encode("utf-8")
vlist.append(w)
w = ""
else:
w += c
if c == "\\":
ignore_quote = True
else:
ignore_quote = False
if w in NONE:
w = None
else:
w = uquote(w).encode("utf-8")
vlist.append(w)
if len(vlist) == 1:
return vlist[0]
return vlist
# -------------------------------------------------------------------------
@classmethod
def _subquery(cls, selectors, op, invert, value):
"""
Construct a sub-query from URL selectors, operator and value
@param selectors: the selector(s)
@param op: the operator
@param invert: invert the query
@param value: the value
"""
v = cls.parse_value(value)
q = None
for fs in selectors:
if op == S3ResourceQuery.LIKE:
# Auto-lowercase and replace wildcard
f = S3FieldSelector(fs).lower()
if isinstance(v, basestring):
v = v.replace("*", "%").lower()
elif isinstance(v, list):
v = [x.replace("*", "%").lower() for x in v if x is not None]
else:
f = S3FieldSelector(fs)
rquery = None
try:
rquery = S3ResourceQuery(op, f, v)
except SyntaxError:
current.log.error("Invalid URL query operator: %s (sub-query ignored)" % op)
q = None
break
# Invert operation
if invert:
rquery = ~rquery
# Add to subquery
if q is None:
q = rquery
elif invert:
q &= rquery
else:
q |= rquery
return q
# =============================================================================
# Helper to combine multiple queries using AND
#
combine = lambda x, y: x & y if x is not None else y
# =============================================================================
class S3URLQueryParser(object):
""" New-style URL Filter Parser """
def __init__(self):
""" Constructor """
self.parser = None
self.ParseResults = None
self.ParseException = None
self._parser()
# -------------------------------------------------------------------------
def _parser(self):
""" Import PyParsing and define the syntax for filter expressions """
# PyParsing available?
try:
import pyparsing as pp
except ImportError:
current.log.error("Advanced filter syntax requires pyparsing, $filter ignored")
return False
# Selector Syntax
context = lambda s, l, t: t[0].replace("[", "(").replace("]", ")")
selector = pp.Word(pp.alphas + "[]~", pp.alphanums + "_.$:[]")
selector.setParseAction(context)
keyword = lambda x, y: x | pp.Keyword(y) if x else pp.Keyword(y)
# Expression Syntax
function = reduce(keyword, S3FieldSelector.OPERATORS)
expression = function + \
pp.Literal("(").suppress() + \
selector + \
pp.Literal(")").suppress()
# Comparison Syntax
comparison = reduce(keyword, S3ResourceQuery.COMPARISON)
# Value Syntax
number = pp.Regex(r"[+-]?\d+(:?\.\d*)?(:?[eE][+-]?\d+)?")
value = number | \
pp.Keyword("NONE") | \
pp.quotedString | \
pp.Word(pp.alphanums + pp.printables)
qe = pp.Group(pp.Group(expression | selector) +
comparison +
pp.originalTextFor(pp.delimitedList(value, combine=True)))
parser = pp.operatorPrecedence(qe, [("not", 1, pp.opAssoc.RIGHT, ),
("and", 2, pp.opAssoc.LEFT, ),
("or", 2, pp.opAssoc.LEFT, ),
])
self.parser = parser
self.ParseResults = pp.ParseResults
self.ParseException = pp.ParseException
return True
# -------------------------------------------------------------------------
def parse(self, expression):
"""
Parse a string expression and convert it into a dict
of filters (S3ResourceQueries).
@parameter expression: the filter expression as string
@return: a dict of {component_alias: filter_query}
"""
query = {}
parser = self.parser
if not expression or parser is None:
return query
try:
parsed = parser.parseString(expression)
except self.ParseException:
current.log.error("Invalid URL Filter Expression: '%s'" %
expression)
else:
if parsed:
query = self.convert_expression(parsed[0])
return query
# -------------------------------------------------------------------------
def convert_expression(self, expression):
"""
Convert a parsed filter expression into a dict of
filters (S3ResourceQueries)
@param expression: the parsed filter expression (ParseResults)
@returns: a dict of {component_alias: filter_query}
"""
ParseResults = self.ParseResults
convert = self.convert_expression
if isinstance(expression, ParseResults):
first, op, second = ([None, None, None] + list(expression))[-3:]
if isinstance(first, ParseResults):
first = convert(first)
if isinstance(second, ParseResults):
second = convert(second)
if op == "not":
return self._not(second)
elif op == "and":
return self._and(first, second)
elif op == "or":
return self._or(first, second)
elif op in S3ResourceQuery.COMPARISON:
return self._query(op, first, second)
elif op in S3FieldSelector.OPERATORS and second:
selector = S3FieldSelector(second)
selector.op = op
return selector
elif op is None and second:
return S3FieldSelector(second)
else:
return None
# -------------------------------------------------------------------------
def _and(self, first, second):
"""
Conjunction of two query {component_alias: filter_query} (AND)
@param first: the first dict
@param second: the second dict
@return: the combined dict
"""
if not first:
return second
if not second:
return first
result = dict(first)
for alias, subquery in second.items():
if alias not in result:
result[alias] = subquery
else:
result[alias] &= subquery
return result
# -------------------------------------------------------------------------
def _or(self, first, second):
"""
Disjunction of two query dicts {component_alias: filter_query} (OR)
@param first: the first query dict
@param second: the second query dict
@return: the combined dict
"""
if not first:
return second
if not second:
return first
if len(first) > 1:
first = {None: reduce(combine, first.values())}
if len(second) > 1:
second = {None: reduce(combine, second.values())}
falias = first.keys()[0]
salias = second.keys()[0]
alias = falias if falias == salias else None
return {alias: first[falias] | second[salias]}
# -------------------------------------------------------------------------
def _not(self, query):
"""
Negation of a query dict
@param query: the query dict {component_alias: filter_query}
"""
if query is None:
return None
if len(query) == 1:
alias, sub = query.items()[0]
if sub.op == S3ResourceQuery.OR and alias is None:
l = sub.left
r = sub.right
lalias = self._alias(sub.left.left)
ralias = self._alias(sub.right.left)
if lalias == ralias:
return {alias: ~sub}
else:
# not(A or B) => not(A) and not(B)
return {lalias: ~sub.left, ralias: ~sub.right}
else:
if sub.op == S3ResourceQuery.NOT:
return {alias: sub.left}
else:
return {alias: ~sub}
else:
return {None: ~reduce(combine, query.values())}
# -------------------------------------------------------------------------
def _query(self, op, first, second):
"""
Create an S3ResourceQuery
@param op: the operator
@param first: the first operand (=S3FieldSelector)
@param second: the second operand (=value)
"""
if not isinstance(first, S3FieldSelector):
return {}
selector = first
alias = self._alias(selector)
value = S3URLQuery.parse_value(second.strip())
if op == S3ResourceQuery.LIKE:
if isinstance(value, basestring):
value = value.replace("*", "%").lower()
elif isinstance(value, list):
value = [x.replace("*", "%").lower() for x in value if x is not None]
return {alias: S3ResourceQuery(op, selector, value)}
# -------------------------------------------------------------------------
@staticmethod
def _alias(selector):
"""
Get the component alias from an S3FieldSelector (DRY Helper)
@param selector: the S3FieldSelector
@return: the alias as string or None for the master resource
"""
alias = None
if selector and isinstance(selector, S3FieldSelector):
prefix = selector.name.split("$", 1)[0]
if "." in prefix:
alias = prefix.split(".", 1)[0]
if alias in ("~", ""):
alias = None
return alias
# END =========================================================================
| ScottBuchanan/eden | modules/s3/s3query.py | Python | mit | 82,174 | 0.001217 |
"""
A collection of utility and helper modules.
These differ from notary_utils in that they do not depend on or need to connect to the notary database.
"""
| danwent/Perspectives-Server | util/__init__.py | Python | gpl-3.0 | 156 | 0.00641 |
__author__ = 'deevarvar'
import string
import random
import os
#generate a random string
def string_generator(size=6, chars=string.ascii_letters+string.digits):
return ''.join(random.choice(chars) for _ in range(size))
#emulate touch cmd
def touchFile(fname, time=None):
with open(fname, 'a'):
os.utime(fname,time)
| deevarvar/myLab | book/tlpi_zhiye/utlib/ut_util.py | Python | mit | 335 | 0.01194 |
#!/usr/bin/env python
# -*- coding: iso-8859-15 -*-
"""
Raspymc is a multimedia centre exposed via a http server built with bottlepy
Copyright (C) 2013 Giancarlo Fringuello
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/>.
"""
import os, inspect, ConfigParser, pickle
from utils import *
from logger import*
from track_obj import *
CNF_SERVER_PATH = sys.path[0]
CNF_FOLDER_PATH = ""
CNF_PLAYLIST_PATH = CNF_SERVER_PATH + "/config/playlist.pkl"
CNF_FOLDER_PATH = CNF_SERVER_PATH + "/config/"
CNF_CONFIG_FILE = CNF_FOLDER_PATH + "config.ini"
#
# Loads the saved playlist from file
def get_playlist():
log(LOG_INFO, inspect.currentframe().f_lineno, "conf_manager.py::load_playlist()")
l_playlist = []
try:
with open(CNF_PLAYLIST_PATH, 'rb') as l_input:
l_playlist = pickle.load(l_input)
except:
log(LOG_WARNING, inspect.currentframe().f_lineno, "conf_manager.py::load_playlist()", "unexisting playlist file: " + CNF_PLAYLIST_PATH)
return l_playlist
def store_playlist(p_list):
log(LOG_INFO, inspect.currentframe().f_lineno, "conf_manager.py::store_playlist()")
try:
with open(CNF_PLAYLIST_PATH, 'wb') as l_output:
pickle.dump(p_list, l_output, pickle.HIGHEST_PROTOCOL)
except:
log(LOG_WARNING, inspect.currentframe().f_lineno, "conf_manager.py::store_playlist()", "unexisting playlist file: " + CNF_PLAYLIST_PATH)
#
# Loads the configuration from file
def get_folder_path():
log(LOG_INFO, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()")
global CNF_FOLDER_PATH
global CNF_PLAYLIST_PATH
global SERVER_PATH
l_config_parser = ConfigParser.ConfigParser()
l_clean_configuration = False
if not os.path.isdir(CNF_FOLDER_PATH): # if config directory does not exist, create it
os.makedirs(CNF_FOLDER_PATH)
log(LOG_WARNING, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()", CNF_FOLDER_PATH + " did not exist, it has been created")
if os.path.isfile(CNF_CONFIG_FILE):
try:
l_config_parser.read(CNF_CONFIG_FILE)
if l_config_parser.has_section("PATH"):
if l_config_parser.has_option("PATH", "CNF_FOLDER_PATH"):
CNF_FOLDER_PATH = l_config_parser.get("PATH","CNF_FOLDER_PATH")
else:
l_clean_configuration = True
else:
# if section does not exist
l_clean_configuration = True
log(LOG_VERBOSE, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()", "unable to load CNF_FOLDER_PATH, using home as default, new config.ini will be generated.")
except:
# if unable to read file (e.g. file damaged)
l_clean_configuration = True
log(LOG_WARNING, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()", "exception: unable to load CNF_FOLDER_PATH from " + CNF_CONFIG_FILE + ", using home path as default, new config.ini will be generated.")
else:
l_clean_configuration = True
log(LOG_WARNING, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()", "no configuration file found, new config.ini will be generated.")
if l_clean_configuration:
# cleanup config file
for l_section in l_config_parser.sections():
l_config_parser.remove_section(l_section)
l_config_parser.add_section("PATH")
l_config_parser.set("PATH", "CNF_FOLDER_PATH", os.path.expanduser("~"))
l_config_parser.write(file(CNF_CONFIG_FILE, 'w'))
if "" == CNF_FOLDER_PATH:
CNF_FOLDER_PATH = os.path.expanduser("~")
log(LOG_VERBOSE, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()", "CNF_FOLDER_PATH = " + CNF_FOLDER_PATH)
log(LOG_VERBOSE, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()", "CNF_PLAYLIST_PATH = " + CNF_PLAYLIST_PATH)
log(LOG_VERBOSE, inspect.currentframe().f_lineno, "conf_manager.py::load_configuration()", "CNF_SERVER_PATH = " + CNF_SERVER_PATH)
return CNF_FOLDER_PATH
def get_server_path():
return SERVER_PATH
def get_playlist_path():
return CNF_PLAYLIST_PATH | GiancarloF/raspymc_server | core/conf_manager.py | Python | gpl-3.0 | 4,528 | 0.023852 |
#!/usr/bin/env python
from __future__ import print_function
import sys
import json
import csv
import StringIO
import io
from dictUtil import as_dict, merge_dicts
import urllib
# import jq
from itertools import izip
from logUtil import logging
# for manifest introspection only
import inspect
from pyspark import SparkContext
class FileUtil(object):
def __init__(self, sparkContext):
self.sc = sparkContext
## Support for entries into manifest
# any entry created thus
# should have spark_context, name of caller, module of caller
# untested: do not use
def makeEntry(self, **kwargs):
entry = dict(**kwargs)
entry["spark_context"] = self.sc
op = kwargs.get("operation", None)
if not op:
try:
st = inspect.stack()
# stack exists
if len(st)>=2:
# look up one stack frame, retrieve the function name[3]
op = st[1][3]
# stack frame memory leak could be very bad, so be careful
del st
except:
pass
mdl = kwargs.get("module", None)
if not mdl:
try:
st = inspect.stack()
# stack exists
if len(st)>=2:
# look up one stack frame, retrieve the module it belongs to
mdl = inspect.getmodule(st[0]).__name__
# stack frame memory leak could be very bad, so be careful
del st
except:
pass
entry["module"] = mdl
return entry
## GENERIC
## Herein:
## file_format is in {text, sequence}
## data_type is in {csv, json, jsonlines(=keyless)}
def load_file(self, filename, file_format='sequence', data_type='json', **kwargs):
try:
handlerName = FileUtil.load_dispatch_table[(file_format, data_type)]
handler = getattr(self, handlerName)
rdd = handler(filename, **kwargs)
# TBD: return (rdd, manifestEntry)
# entry = self.makeEntry(input_filename=filename,
# input_file_format=file_format,
# input_data_type=data_type)
# return (rdd, entry)
#logging.info("Loaded {}/{} file {}: {} elements".format(file_format, data_type, filename, rdd.count()))
return rdd
except KeyError:
raise NotImplementedError("File_Format={}, data_type={}".format(file_format, data_type))
load_dispatch_table = {("sequence", "json"): "_load_sequence_json_file",
("sequence", "csv"): "_load_sequence_csv_file",
("text", "json"): "_load_text_json_file",
("text", "jsonlines"): "_load_text_jsonlines_file",
("text", "csv"): "_load_text_csv_file"}
def _load_sequence_json_file(self, filename, **kwargs):
rdd_input = self.sc.sequenceFile(filename)
rdd_json = rdd_input.mapValues(lambda x: json.loads(x))
return rdd_json
def _load_text_json_file(self, filename, separator='\t', **kwargs):
# rdd_input = self.sc.textFile(filename)
# rdd_json = rdd_input.map(lambda x: FileUtil.__parse_json_line(x, separator))
rdd_strings = self.sc.textFile(filename)
rdd_split = rdd_strings.map(lambda line: tuple(line.split(separator, 1)))
def tryJson(v):
try:
j = json.loads(v)
return j
except Exception as e:
print("failed [{}] on {}".format(str(e), v), file=sys.stderr)
rdd_json = rdd_split.mapValues(lambda v: tryJson(v))
return rdd_json
def _load_text_jsonlines_file(self, filename, keyPath='.uri', **kwargs):
rdd_strings = self.sc.textFile(filename)
def tryJson(line):
try:
obj = json.loads(line)
# We ignore all but the first occurrence of key
try:
# key = jq.jq(keyPath).transform(obj, multiple_output=False)
key = obj["uri"]
except:
key = None
if key:
# i.e., a paired RDD
return (key, obj)
else:
raise ValueError("No key (per {}) in line {}".format(keyPath, line))
except Exception as e:
print("failed [{}] on {}".format(str(e), line), file=sys.stderr)
rdd_json = rdd_strings.map(lambda line: tryJson(line))
return rdd_json
def _load_sequence_csv_file(self, filename, **kwargs):
"""Should emulate text/csv"""
raise NotImplementedError("File_Format=sequence, data_type=csv")
def _load_text_csv_file(self, filename, separator=',', **kwargs):
"""Return a pair RDD where key is taken from first column, remaining columns are named after their column id as string"""
rdd_input = self.sc.textFile(filename)
def load_csv_record(line):
input_stream = StringIO.StringIO(line)
reader = csv.reader(input_stream, delimiter=',')
# key in first column, remaining columns 1..n become dict key values
payload = reader.next()
key = payload[0]
rest = payload[1:]
# generate dict of "1": first value, "2": second value, ...
d = {}
for (cell,i) in izip(rest, range(1,1+len(rest))):
d[str(i)] = cell
# just in case, add "0": key
d["0"] = key
return (key, d)
rdd_parsed = rdd_input.map(load_csv_record)
return rdd_parsed
## SAVE
def save_file(self, rdd, filename, file_format='sequence', data_type='json', **kwargs):
try:
handlerName = FileUtil.save_dispatch_table[(file_format, data_type)]
handler = getattr(self, handlerName)
rdd = handler(rdd, filename, **kwargs)
# TBD: return (rdd, manifestEntry)
# entry = self.makeEntry(output_filename=filename,
# output_file_format=file_format,
# output_data_type=data_type)
# return (rdd, entry)
return rdd
except KeyError:
raise NotImplementedError("File_Format={}, data_type={}".format(file_format, data_type))
save_dispatch_table = {("sequence", "json"): "_save_sequence_json_file",
("sequence", "csv"): "_save_sequence_csv_file",
("text", "json"): "_save_text_json_file",
("text", "csv"): "_save_text_csv_file"}
def _save_sequence_json_file(self, rdd, filename, separator='\t', **kwargs):
# regardless of whatever it is, key is retained
rdd.mapValues(lambda x: json.dumps(x)).saveAsSequenceFile(filename)
return filename
def _save_text_json_file(self, rdd, filename, separator='\t', **kwargs):
rdd_json = rdd.map(lambda (k, v): FileUtil.__dump_as_json(k, v, separator))
# this saves the (<uri>, <serialized_json_string>) as as text repn
# perhaps a regular readable text file uri<separator>JSON will be more useful?
rdd_json.saveAsTextFile(filename)
return filename
def _save_text_csv_file(self, rdd, filename, separator='\t', encoding='utf-8', **kwargs):
with io.open(filename, 'wb', encoding=encoding) as f:
wrtr = csv.writer(f, delimiter=separator)
def save_csv_record(line):
wrtr.writerow(line)
rdd.foreach(save_csv_record)
return filename
def _save_sequence_csv_file(self, rdd, filename, separator='\t', **kwargs):
raise NotImplementedError("File_Format=sequence, data_type=csv")
## JSON
@staticmethod
def __parse_json_line(line, separator):
line = line.strip()
if len(line) > 0:
line_elem = line.split(separator, 2)
if len(line_elem) > 1:
return line_elem[0], json.loads(line_elem[1])
elif len(line_elem) == 1:
return '', json.loads(line_elem[0])
@staticmethod
def __dump_as_json(key, value, sep):
return key + sep + json.dumps(value)
@staticmethod
def get_json_config(config_spec):
# if it's a dict, or coercible to a dict, return the dict
try:
return as_dict(config_spec)
except TypeError:
pass
# Not a dict
config_file = None
if config_spec.startswith("http"):
# URL: fetch it
config_file = urllib.urlopen(config_spec)
else:
# string: open file with that name
config_file = open(config_spec)
config = json.load(config_file)
# Close any open files
try:
config_file.close()
except:
pass
return config
@staticmethod
def get_config(config_spec):
"""Like get_json_config but does not parse result as JSON"""
config_file = None
if config_spec.startswith("http"):
# URL: fetch it
config_file = urllib.urlopen(config_spec)
else:
# string: open file with that name
config_file = open(config_spec)
config = json.load(config_file)
# Close any open files
try:
config_file.close()
except:
pass
return config
##################################################################
import argparse
def main(argv=None):
'''TEST ONLY: this is called if run from command line'''
parser = argparse.ArgumentParser()
parser.add_argument('-i','--input_file', required=True)
parser.add_argument('--input_file_format', default='sequence')
parser.add_argument('--input_data_type', default='json')
parser.add_argument('--input_separator', default='\t')
parser.add_argument('-o','--output_dir', required=True)
parser.add_argument('--output_file_format', default='sequence')
parser.add_argument('--output_data_type', default='json')
parser.add_argument('--output_separator', default='\t')
args=parser.parse_args()
# can be inconvenient to specify tab on the command line
args.input_separator = "\t" if args.input_separator=='tab' else args.input_separator
args.output_separator = "\t" if args.output_separator=='tab' else args.output_separator
sc = SparkContext(appName="fileUtil")
fUtil = FileUtil(sc)
## CONFIG LOAD
input_kwargs = {"file_format": args.input_file_format,
"data_type": args.input_data_type}
parse_kwargs = {"separator": args.input_separator}
load_kwargs = merge_dicts(input_kwargs, parse_kwargs)
## LOAD
rdd = fUtil.load_file(args.input_file, **load_kwargs)
## CONFIG SAVE
output_kwargs = {"file_format": args.output_file_format,
"data_type": args.output_data_type}
emit_kwargs = {"separator": args.output_separator}
save_kwargs = merge_dicts(output_kwargs, emit_kwargs)
## SAVE
fUtil.save_file(rdd, args.output_dir, **save_kwargs)
if __name__ == "__main__":
"""
Usage: tokenizer.py [input] [config] [output]
"""
main()
| usc-isi-i2/WEDC | spark_dependencies/python_lib/digSparkUtil/fileUtil.py | Python | apache-2.0 | 11,462 | 0.005496 |
''' This script is run as root by the osmc update module. '''
import apt
import socket
import sys
from datetime import datetime
import json
import os
import time
import subprocess
import traceback
from CompLogger import comprehensive_logger as clog
t = datetime
class Logger(object):
def __init__(self, filename="Default.log"):
self.terminal = sys.stdout
self.log = open(filename, "a")
def write(self, message):
self.terminal.write(message)
self.log.write(message)
try:
sys.stdout = Logger("/var/tmp/OSMC_python_apt_log.txt")
except:
pass
@clog(maxlength=1500)
def call_parent(raw_message, data={}):
address = '/var/tmp/osmc.settings.update.sockfile'
print '%s %s sending response' % (t.now(), 'apt_cache_action.py')
message = (raw_message, data)
message = json.dumps(message)
try:
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.connect(address)
sock.sendall(message)
sock.close()
except Exception as e:
return '%s %s failed to connect to parent - %s' % (t.now(), 'apt_cache_action.py', e)
return 'response sent'
class Main(object):
def __init__(self, action):
# with apt.apt_pkg.SystemLock():
# implements a lock on the package system, so that nothing else can alter packages
print '==================================================================='
print '%s %s running' % (t.now(), 'apt_cache_action.py')
self.error_package = ''
self.error_message = ''
self.heading = 'Updater'
self.action = action
self.cache = apt.Cache()
self.block_update_file = '/var/tmp/.suppress_osmc_update_checks'
self.action_to_method = {
'update' : self.update,
'update_manual' : self.update,
'commit' : self.commit,
'fetch' : self.fetch,
'action_list' : self.action_list,
}
try:
self.act()
except Exception as e:
print '%s %s exception occurred' % (t.now(), 'apt_cache_action.py')
print '%s %s exception value : %s' % (t.now(), 'apt_cache_action.py', e)
deets = 'Error Type and Args: %s : %s \n\n %s' % (type(e).__name__, e.args, traceback.format_exc())
# send the error to the parent (parent will kill the progress bar)
call_parent('apt_error', {'error': self.error_message, 'package': self.error_package, 'exception': deets})
self.respond()
print '%s %s exiting' % (t.now(), 'apt_cache_action.py')
print '==================================================================='
def respond(self):
call_parent('apt_cache %s complete' % self.action)
def act(self):
action = self.action_to_method.get(self.action, False)
if action:
action()
else:
print 'Action not in action_to_method dict'
#@clog()
def action_list(self):
''' This method processes a list sent in argv[2], and either installs or remove packages.
The list is sent as a string:
install_packageid1|=|install_packageid2|=|removal_packageid3'''
self.heading = 'App Store'
action_string = sys.argv[2]
action_dict = self.parse_argv2(action_string)
self.update()
self.cache.open()
for pkg in self.cache:
# mark packages as install or remove
if pkg.shortname in action_dict['install']:
pkg.mark_install()
if pkg.shortname in action_dict['removal']:
pkg.mark_delete(purge=True)
# commit
self.commit_action()
if action_dict['removal']:
# if there were removals then remove the packages that arent needed any more
self.update()
self.cache.open()
removals = False
for pkg in self.cache:
if pkg.is_auto_removable:
pkg.mark_delete(purge=True)
removals = True
if removals:
# commit
self.commit_action()
# #@clog()
def parse_argv2(self, action_string):
install = []
removal = []
actions = action_string.split('|=|')
for action in actions:
if action.startswith('install_'):
install.append(action[len('install_'):])
elif action.startswith('removal_'):
removal.append(action[len('removal_'):])
return {'install': install, 'removal': removal}
#@clog()
def update(self):
dprg = Download_Progress(partial_heading='Updating')
self.cache.update(fetch_progress=dprg, pulse_interval=1000)
# call the parent and kill the pDialog
call_parent('progress_bar', {'kill': True})
return '%s %s cache updated' % (t.now(), 'apt_cache_action.py')
#@clog()
def commit(self):
# check whether any packages are broken, if they are then the install needs to take place outside of Kodi
for pkg in self.cache:
if pkg.is_inst_broken or pkg.is_now_broken:
return "%s is BROKEN, cannot proceed with commit" % pkg.shortname
print '%s %s upgrading all packages' % (t.now(), 'apt_cache_action.py')
self.cache.upgrade(True)
print '%s %s committing cache' % (t.now(), 'apt_cache_action.py')
self.commit_action()
#@clog()
def commit_action(self):
dprg = Download_Progress()
iprg = Install_Progress(self)
self.cache.commit(fetch_progress=dprg, install_progress=iprg)
# call the parent and kill the pDialog
call_parent('progress_bar', {'kill': True})
# remove the file that blocks further update checks
try:
os.remove(self.block_update_file)
except:
return 'Failed to remove block_update_file'
return '%s %s cache committed' % (t.now(), 'apt_cache_action.py')
#@clog()
def fetch(self):
self.cache.upgrade(True)
print '%s %s fetching all packages' % (t.now(), 'apt_cache_action.py')
dprg = Download_Progress()
self.cache.fetch_archives(progress=dprg)
# call the parent and kill the pDialog
call_parent('progress_bar', {'kill': True})
return '%s %s all packages fetched' % (t.now(), 'apt_cache_action.py')
class Operation_Progress(apt.progress.base.OpProgress):
def __init__(self):
super(Operation_Progress, self).__init__()
def update(self):
call_parent('progress_bar', {'percent': self.percent, 'heading': self.op, 'message':self.sub_op,})
def done(self):
call_parent('progress_bar', {'kill': True})
class Install_Progress(apt.progress.base.InstallProgress):
def __init__(self, parent):
self.parent = parent
super(Install_Progress, self).__init__()
call_parent('progress_bar', {'percent': 0, 'heading': self.parent.heading, 'message':'Starting Installation'})
#@clog()
def error(self, pkg, errormsg):
print 'ERROR!!! \n%s\n' % errormsg
try:
pkgname = os.path.basename(pkg).split('_')
print 'Package affected!!! \n%s\n' % pkgname
self.parent.error_package = pkgname[0]
if len(pkgname) > 1:
self.parent.error_package += ' (' + pkgname[1] + ')'
except:
self.parent.error_package = '(unknown package)'
self.parent.error_message = errormsg
''' (Abstract) Called when a error is detected during the install. '''
# The following method should be overridden to implement progress reporting for dpkg-based runs
# i.e. calls to run() with a filename:
# def processing(self, pkg, stage):
# ''' This method is called just before a processing stage starts. The parameter pkg is the name of the
# package and the parameter stage is one of the stages listed in the dpkg manual under the
# status-fd option, i.e. "upgrade", "install" (both sent before unpacking), "configure", "trigproc",
# "remove", "purge". '''
# def dpkg_status_change(self, pkg, status):
# ''' This method is called whenever the dpkg status of the package changes. The parameter pkg is the
# name of the package and the parameter status is one of the status strings used in the status file
# (/var/lib/dpkg/status) and documented in dpkg(1). '''
# The following methods should be overridden to implement progress reporting for run() calls
# with an apt_pkg.PackageManager object as their parameter:
#@clog()
def status_change(self, pkg, percent, status):
''' This method implements progress reporting for package installation by APT and may be extended to
dpkg at a later time. This method takes two parameters: The parameter percent is a float value
describing the overall progress and the parameter status is a string describing the current status
in an human-readable manner. '''
diff = t.now() - self.pulse_time
if (diff.total_seconds() * 10) < 12:
return True
self.pulse_time = t.now()
call_parent('progress_bar', {'percent': int(percent), 'heading': self.parent.heading, 'message': status})
#@clog()
def start_update(self):
''' This method is called before the installation of any package starts. '''
self.pulse_time = t.now()
return 'Start !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
#@clog()
def finish_update(self):
''' This method is called when all changes have been applied. '''
return 'Stop !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
class Download_Progress(apt.progress.base.AcquireProgress):
def __init__(self, partial_heading='Downloading'):
super(Download_Progress, self).__init__()
self.partial_heading = partial_heading
call_parent('progress_bar', {'percent': 0, 'heading': 'Downloading Update', 'message':'Starting Download',})
#@clog()
def start(self):
''' Invoked when the Acquire process starts running. '''
self.pulse_time = t.now()
return 'Start !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
#@clog()
def stop(self):
''' Invoked when the Acquire process stops running. '''
return 'Stop !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
#@clog()
def fetch(self, item):
''' Invoked when an item is being fetched. '''
dsc = item.description.split('/')
self.fetching = self.partial_heading + ': ' + dsc[-1]
# call_parent('progress_bar',{'message': 'Downloading: ' + dsc[-1]})
return 'Fetch' + item.description + '++++++++++++++++++++++++++++++'
#@clog()
def pulse(self, owner):
''' Periodically invoked as something is being downloaded. '''
# if the pulse is less than one second since the last one then ignore the pulse
# this needs to be done as the parents _daemon only checks the queue once a second
diff = t.now() - self.pulse_time
if (diff.total_seconds() * 10) < 11:
return True
else:
self.pulse_time = t.now()
print 'Pulse ==========================================='
print 'current_items', self.current_items
print 'total_items', self.total_items
print 'total_bytes', self.total_bytes
print 'fetched_bytes', self.fetched_bytes
print 'current_bytes', self.current_bytes
print 'current_cps', self.current_cps
print 'Pulse ==========================================='
pct = int(self.current_bytes / float(self.total_bytes) * 100)
cps = self.current_cps / 1024.0
if cps > 1024:
cps = '{0:.2f} MBps'.format(cps / 1024)
else:
cps = '{0:.0f} kBps'.format(cps)
cmb = self.current_bytes / 1048576.0
tmb = self.total_bytes / 1048576.0
msg = self.fetching
hdg = '{0:d} / {1:d} items -- {2:} -- {3:.1f} / {4:.1f}MB'.format(self.current_items, self.total_items, cps, cmb, tmb)
call_parent('progress_bar', {'percent': pct, 'heading': hdg, 'message': msg})
return True
#@clog()
def done(self, item):
''' Invoked when an item has finished downloading. '''
return 'Done ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^'
if __name__ == "__main__":
if len(sys.argv) > 1:
action = sys.argv[1]
m = Main(action)
del m
| indie1982/osmc-fixes | package/mediacenter-addon-osmc/src/script.module.osmcsetting.updates/resources/lib/apt_cache_action.py | Python | gpl-2.0 | 11,354 | 0.035406 |
#!/usr/bin/env python
#
# This library is free software, distributed under the terms of
# the GNU Lesser General Public License Version 3, or any later version.
# See the COPYING file included in this archive
#
# The docstrings in this module contain epytext markup; API documentation
# may be created by processing this file with epydoc: http://epydoc.sf.net
""" This module defines the charaterizing constants of the Kademlia network
C{checkRefreshInterval} and C{udpDatagramMaxSize} are implementation-specific
constants, and do not affect general Kademlia operation.
"""
######### KADEMLIA CONSTANTS ###########
#: Small number Representing the degree of parallelism in network calls
alpha = 3
#: Maximum number of contacts stored in a bucket; this should be an even number
k = 8
#: Timeout for network operations (in seconds)
rpcTimeout = 5
# Delay between iterations of iterative node lookups (for loose parallelism) (in seconds)
iterativeLookupDelay = rpcTimeout / 2
#: If a k-bucket has not been used for this amount of time, refresh it (in seconds)
refreshTimeout = 3600 # 1 hour
#: The interval at which nodes replicate (republish/refresh) data they are holding
replicateInterval = refreshTimeout
# The time it takes for data to expire in the network; the original publisher of the data
# will also republish the data at this time if it is still valid
dataExpireTimeout = 86400 # 24 hours
######## IMPLEMENTATION-SPECIFIC CONSTANTS ###########
#: The interval in which the node should check its whether any buckets need refreshing,
#: or whether any data needs to be republished (in seconds)
checkRefreshInterval = refreshTimeout/5
#: Max size of a single UDP datagram, in bytes. If a message is larger than this, it will
#: be spread accross several UDP packets.
udpDatagramMaxSize = 8192 # 8 KB
| tjgillies/distributed-draw | entangled/kademlia/constants.py | Python | lgpl-3.0 | 1,820 | 0.006593 |
from sqlalchemy import *
from migrate import *
from migrate.changeset import schema
pre_meta = MetaData()
post_meta = MetaData()
task = Table('task', post_meta,
Column('id', Integer, primary_key=True, nullable=False),
Column('parent_id', Integer, default=ColumnDefault(0)),
Column('body', String),
Column('taskname', String(length=140)),
Column('timestamp', DateTime),
Column('user_id', Integer),
Column('project_id', Integer),
Column('status', String(length=10)),
Column('depth', Integer, default=ColumnDefault(0)),
)
def upgrade(migrate_engine):
# Upgrade operations go here. Don't create your own engine; bind
# migrate_engine to your metadata
pre_meta.bind = migrate_engine
post_meta.bind = migrate_engine
post_meta.tables['task'].columns['parent_id'].create()
def downgrade(migrate_engine):
# Operations to reverse the above upgrade go here.
pre_meta.bind = migrate_engine
post_meta.bind = migrate_engine
post_meta.tables['task'].columns['parent_id'].drop()
| itJunky/web-tasker.py | db_repository/versions/028_migration.py | Python | gpl-2.0 | 1,041 | 0.000961 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'zappyk'
import sys, subprocess
from gi.repository import Gtk, Gio
from gi.repository import GLib
###############################################################################
class MyWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="Hello World")
self.button = Gtk.Button(label="Click Here")
self.button.connect("clicked", self.on_button_clicked)
self.add(self.button)
def on_button_clicked(self, widget):
print("Hello World")
#______________________________________________________________________________
#
def test_1():
win = MyWindow()
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()
###############################################################################
class Handler():
def __init__(self, cmd):
self.cmd = CommandTextView(cmd)
def on_button1_clicked(self, widget):
self.cmd.run()
pass
def on_button2_clicked(self, widget):
pass
def on_textview1_add(self, widget):
widget.inset
pass
def on_window1_delete_event(self, *args):
Gtk.main_quit(*args)
###############################################################################
class CommandTextView(Gtk.TextView):
''' NICE TEXTVIEW THAT READS THE OUTPUT OF A COMMAND SYNCRONOUSLY '''
def __init__(self, command):
'''COMMAND : THE SHELL COMMAND TO SPAWN'''
super(CommandTextView, self).__init__()
self.command = command
def run(self):
''' RUNS THE PROCESS '''
proc = subprocess.Popen(self.command, stdout = subprocess.PIPE) # SPAWNING
GLib.io_add_watch(proc.stdout, # FILE DESCRIPTOR
GLib.IO_IN, # CONDITION
self.write_to_buffer) # CALLBACK
def write_to_buffer(self, fd, condition):
if condition == GLib.IO_IN: #IF THERE'S SOMETHING INTERESTING TO READ
#CZ#char = fd.read(1) # WE READ ONE BYTE PER TIME, TO AVOID BLOCKING
char = fd.read().decode("utf-8")
buff = self.get_buffer()
buff.insert_at_cursor(char) # WHEN RUNNING DON'T TOUCH THE TEXTVIEW!!
return True # FUNDAMENTAL, OTHERWISE THE CALLBACK ISN'T RECALLED
else:
return False # RAISED AN ERROR: EXIT AND I DON'T WANT TO SEE YOU ANYMORE
#______________________________________________________________________________
#
def test_2():
cmd = CommandTextView("find")
win = Gtk.Window()
win.connect("delete-event", lambda wid, event: Gtk.main_quit()) # DEFINING CALLBACKS WITH LAMBDAS
win.set_size_request(200,300)
win.add(cmd)
win.show_all()
cmd.run()
Gtk.main()
#______________________________________________________________________________
#
def test_3():
cmd = CommandTextView("find")
builder = Gtk.Builder()
builder.add_from_file("test-gui-Gtk.glade")
builder.connect_signals(Handler(cmd))
window = builder.get_object("window1")
window.show_all()
cmd.run()
Gtk.main()
###############################################################################
class HeaderBarWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="Stack Demo")
#CZ#Gtk.Window.__init__(self, title="Stack Demo", type=Gtk.WINDOW_TOPLEVEL)
self.set_border_width(10)
self.set_default_size(400, 200)
#CZ#self.has_toplevel_focus()
#hb = Gtk.HeaderBar()
#hb.props.show_close_button = True
#hb.props.title = "HeaderBar example"
#self.set_titlebar(hb)
button = Gtk.Button()
icon = Gio.ThemedIcon(name="mail-send-receive-symbolic")
image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
button.add(image)
#hb.pack_end(button)
box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
Gtk.StyleContext.add_class(box.get_style_context(), "linked")
button = Gtk.Button()
button.add(Gtk.Arrow(Gtk.ArrowType.LEFT, Gtk.ShadowType.NONE))
box.add(button)
button = Gtk.Button()
button.add(Gtk.Arrow(Gtk.ArrowType.RIGHT, Gtk.ShadowType.NONE))
box.add(button)
#hb.pack_start(box)
self.add(Gtk.TextView())
#______________________________________________________________________________
#
def test_4():
win = HeaderBarWindow()
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()
#______________________________________________________________________________
#
if __name__ == '__main__':
test_4() | zappyk-github/zappyk-python | src/src_zappyk/developing/test-gui-Gtk.py | Python | gpl-2.0 | 4,640 | 0.009483 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ODB++ surface parser components
"""
import re
from collections import namedtuple
from .Decoder import DecoderOption
from .Treeifier import TreeifierRule
from .PolygonParser import Polygon
from .Structures import Polarity, polarity_map
from .Attributes import parse_attributes
__all__ = ["surface_decoder_options",
"SurfaceBeginTag", "surface_treeify_rules",
"surface_decoder_options",
"SurfaceEndTag", "Surface", "Polarity"]
Surface = namedtuple("Surface", ["polarity", "dcode", "polygons", "attributes"])
SurfaceBeginTag = namedtuple("SurfaceBeginTag", ["polarity", "dcode", "attributes"])
SurfaceEndTag = namedtuple("SurfaceEndTag", [])
# Surface syntax regular expressions
_surface_re = re.compile(r"^S\s+([PN])\s+(\d+)\s*(;\s*.+?)?$")
_surface_end_re = re.compile(r"^SE\s*$")
def _parse_surface_start(match):
"Parse a surface begin tag regex match"
polarity, dcode, attributes = match.groups()
# Parse attribute string
attributes = parse_attributes(attributes[1:]) \
if attributes is not None else {}
return SurfaceBeginTag(polarity_map[polarity],
int(dcode), attributes)
def _parse_surface_end(match):
"Parse a surface end tag regex match"
return SurfaceEndTag()
surface_decoder_options = [
DecoderOption(_surface_re, _parse_surface_start),
DecoderOption(_surface_end_re, _parse_surface_end)
]
def _treeifier_process_surface(elems):
"""Treeifier processor function for surfaces."""
polygons = []
polarity, dcode, attributes = elems[0] # Poly begin tag
for elem in elems[1:]: # Iterate everything except the end tag
if isinstance(elem, Polygon):
polygons.append(elem)
# Build polygon structure
return Surface(polarity, dcode, polygons, attributes)
surface_treeify_rules = [
TreeifierRule(SurfaceBeginTag, SurfaceEndTag, _treeifier_process_surface),
]
| ulikoehler/ODBPy | ODBPy/SurfaceParser.py | Python | apache-2.0 | 1,978 | 0.004044 |
# uncompyle6 version 2.9.10
# Python bytecode 2.7 (62211)
# Decompiled from: Python 3.6.0b2 (default, Oct 11 2016, 05:27:10)
# [GCC 6.2.0 20161005]
# Embedded file name: type_Result.py
from types import *
RESULT_TYPE_PROCESS_HIDE = 0
RESULT_TYPE_PROCESS_UNHIDE = 1
class Result:
def __init__(self):
self.__dict__['type'] = 0
self.__dict__['item'] = ''
self.__dict__['metaData'] = ''
def __getattr__(self, name):
if name == 'type':
return self.__dict__['type']
if name == 'item':
return self.__dict__['item']
if name == 'metaData':
return self.__dict__['metaData']
raise AttributeError("Attribute '%s' not found" % name)
def __setattr__(self, name, value):
if name == 'type':
self.__dict__['type'] = value
elif name == 'item':
self.__dict__['item'] = value
elif name == 'metaData':
self.__dict__['metaData'] = value
else:
raise AttributeError("Attribute '%s' not found" % name)
def Marshal(self, mmsg):
from mcl.object.Message import MarshalMessage
submsg = MarshalMessage()
submsg.AddU8(MSG_KEY_RESULT_TYPE, self.__dict__['type'])
submsg.AddStringUtf8(MSG_KEY_RESULT_ITEM, self.__dict__['item'])
submsg.AddStringUtf8(MSG_KEY_RESULT_METADATA, self.__dict__['metaData'])
mmsg.AddMessage(MSG_KEY_RESULT, submsg)
def Demarshal(self, dmsg, instance=-1):
import mcl.object.Message
msgData = dmsg.FindData(MSG_KEY_RESULT, mcl.object.Message.MSG_TYPE_MSG, instance)
submsg = mcl.object.Message.DemarshalMessage(msgData)
self.__dict__['type'] = submsg.FindU8(MSG_KEY_RESULT_TYPE)
self.__dict__['item'] = submsg.FindString(MSG_KEY_RESULT_ITEM)
self.__dict__['metaData'] = submsg.FindString(MSG_KEY_RESULT_METADATA) | DarthMaulware/EquationGroupLeaks | Leak #5 - Lost In Translation/windows/Resources/Dsz/PyScripts/Lib/dsz/mca/security/cmd/hide/type_Result.py | Python | unlicense | 1,899 | 0.002633 |
# -*- coding: utf-8 -*-
#
# TaskBuster documentation build configuration file, created by
# sphinx-quickstart on Tue Jun 16 10:01:14 2015.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
sys.path.insert(0, os.path.abspath('..'))
from django.conf import settings
settings.configure()
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'TaskBuster'
copyright = u'2015, Patrick Mazulo'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '0.1'
# The full version, including alpha/beta/rc tags.
release = '0.1.0'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'TaskBusterdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
('index', 'TaskBuster.tex', u'TaskBuster Documentation',
u'Patrick Mazulo', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'taskbuster', u'TaskBuster Documentation',
[u'Patrick Mazulo'], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'TaskBuster', u'TaskBuster Documentation',
u'Patrick Mazulo', 'TaskBuster', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
| mazulo/taskbuster-boilerplate | docs/conf.py | Python | mit | 8,303 | 0.006263 |
# -*- coding: utf-8 -*-
"""The plist event formatter."""
from plaso.formatters import interface
from plaso.formatters import manager
class PlistFormatter(interface.ConditionalEventFormatter):
"""Formatter for a plist key event."""
DATA_TYPE = u'plist:key'
FORMAT_STRING_SEPARATOR = u''
FORMAT_STRING_PIECES = [
u'{root}/',
u'{key}',
u' {desc}']
SOURCE_LONG = u'Plist Entry'
SOURCE_SHORT = u'PLIST'
manager.FormattersManager.RegisterFormatter(PlistFormatter)
| ostree/plaso | plaso/formatters/plist.py | Python | apache-2.0 | 497 | 0.012072 |
import sublime, sublime_plugin
import difflib
import time
import datetime
import codecs
import os
def diff_changes(file_name, result):
try:
if "Body" in result:
server = result["Body"].splitlines()
elif "Markup" in result:
server = result["Markup"].splitlines()
local = codecs.open(file_name, "r", "utf-8").read().splitlines()
except UnicodeDecodeError:
show_diff_panel("Diff only works with UTF-8 files")
return
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
bdate_literal = result["LastModifiedDate"].split(".")[0]
server_date = datetime.datetime.strptime(bdate_literal, "%Y-%m-%dT%H:%M:%S")
local_date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
diff = difflib.unified_diff(server, local, "Server", "Local ", server_date, local_date, lineterm='')
difftxt = u"\n".join(line for line in diff)
if difftxt == "":
show_diff_panel("There is no difference between %s and server" % os.path.basename(file_name))
return
show_diff_panel(difftxt)
def diff_files(file_name, other_file_name):
try:
this_file_content = codecs.open(file_name, "r", "utf-8").read().splitlines()
other_file_content = codecs.open(other_file_name, "r", "utf-8").read().splitlines()
except UnicodeDecodeError:
show_diff_panel("Diff only works with UTF-8 files")
return
diff = difflib.unified_diff(this_file_content, other_file_content, "Server", "Local ", "", "", lineterm='')
difftxt = u"\n".join(line for line in diff)
if difftxt == "":
show_diff_panel("There is no difference between %s and %s" % (
file_name,
other_file_name
))
return
show_diff_panel(difftxt)
def show_diff_panel(difftxt):
win = sublime.active_window()
v = win.create_output_panel('diff_with_server')
v.assign_syntax('Packages/Diff/Diff.tmLanguage')
v.run_command('append', {'characters': difftxt})
win.run_command("show_panel", {"panel": "output.diff_with_server"})
| xjsender/haoide | salesforce/lib/diff.py | Python | mit | 2,098 | 0.005243 |
# posting to: http://localhost:3000/api/articles/update/:articleid with title, content
# changes title, content
#
# id1: (darwinbot1 P@ssw0rd!! 57d748bc67d0eaf026dff431) <-- this will change with differing mongo instances
import time # for testing, this is not good
import requests # if not installed already, run python -m pip install requests OR pip install requests, whatever you normally do
r = requests.post('http://localhost:80/api/games/search', data={'devkey': "581ced5d7563227053011823", 'username': 'darwinbot2'}) # search for new game
json = r.json() # when request comes back, that means you've found a match! (validation if server goes down?)
print(json)
gameID = json['gameID']
playerID = json['playerID']
print(gameID)
print(playerID)
input = ' '
while input != '':
input = raw_input('input move: ')
r = requests.post('http://localhost:80/api/games/submit/' + gameID, data={'playerID': playerID, 'move': input, 'devkey': "581ced5d7563227053011823"}); # submit sample move
json = r.json()
print(json) | dubwub/F2016-UPE-AI | sample_AIs/darwinbot2.py | Python | mit | 1,018 | 0.016699 |
from django.apps import AppConfig
class AlarmConfig(AppConfig):
name = 'alarm'
| pythonvietnam/nms | apps/alarm/apps.py | Python | mit | 85 | 0 |
# Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import json
import logging
import socket
import sys
from telemetry.core import util
from telemetry.core import exceptions
from telemetry.core.chrome import inspector_console
from telemetry.core.chrome import inspector_memory
from telemetry.core.chrome import inspector_page
from telemetry.core.chrome import inspector_runtime
from telemetry.core.chrome import inspector_timeline
from telemetry.core.chrome import png_bitmap
from telemetry.core.chrome import websocket
class InspectorException(Exception):
pass
class InspectorBackend(object):
def __init__(self, browser, browser_backend, debugger_url):
assert debugger_url
self._browser = browser
self._browser_backend = browser_backend
self._debugger_url = debugger_url
self._socket = None
self._domain_handlers = {}
self._cur_socket_timeout = 0
self._next_request_id = 0
self._console = inspector_console.InspectorConsole(self)
self._memory = inspector_memory.InspectorMemory(self)
self._page = inspector_page.InspectorPage(self)
self._runtime = inspector_runtime.InspectorRuntime(self)
self._timeline = inspector_timeline.InspectorTimeline(self)
def __del__(self):
self.Disconnect()
def _Connect(self):
if self._socket:
return
self._socket = websocket.create_connection(self._debugger_url)
self._cur_socket_timeout = 0
self._next_request_id = 0
def Disconnect(self):
for _, handlers in self._domain_handlers.items():
_, will_close_handler = handlers
will_close_handler()
self._domain_handlers = {}
if self._socket:
self._socket.close()
self._socket = None
# General public methods.
@property
def browser(self):
return self._browser
@property
def url(self):
self.Disconnect()
return self._browser_backend.tab_list_backend.GetTabUrl(self._debugger_url)
def Activate(self):
self._Connect()
self._browser_backend.tab_list_backend.ActivateTab(self._debugger_url)
def Close(self):
self.Disconnect()
self._browser_backend.tab_list_backend.CloseTab(self._debugger_url)
# Public methods implemented in JavaScript.
def WaitForDocumentReadyStateToBeComplete(self, timeout):
util.WaitFor(
lambda: self._runtime.Evaluate('document.readyState') == 'complete',
timeout)
def WaitForDocumentReadyStateToBeInteractiveOrBetter(
self, timeout):
def IsReadyStateInteractiveOrBetter():
rs = self._runtime.Evaluate('document.readyState')
return rs == 'complete' or rs == 'interactive'
util.WaitFor(IsReadyStateInteractiveOrBetter, timeout)
@property
def screenshot_supported(self):
if self._runtime.Evaluate(
'window.chrome.gpuBenchmarking === undefined'):
return False
if self._runtime.Evaluate(
'window.chrome.gpuBenchmarking.beginWindowSnapshotPNG === undefined'):
return False
# TODO(dtu): Also check for Chrome branch number, because of a bug in
# beginWindowSnapshotPNG in older versions. crbug.com/171592
return True
def Screenshot(self, timeout):
if self._runtime.Evaluate(
'window.chrome.gpuBenchmarking === undefined'):
raise Exception("Browser was not started with --enable-gpu-benchmarking")
if self._runtime.Evaluate(
'window.chrome.gpuBenchmarking.beginWindowSnapshotPNG === undefined'):
raise Exception("Browser does not support window snapshot API.")
self._runtime.Evaluate("""
if(!window.__telemetry) {
window.__telemetry = {}
}
window.__telemetry.snapshotComplete = false;
window.__telemetry.snapshotData = null;
window.chrome.gpuBenchmarking.beginWindowSnapshotPNG(
function(snapshot) {
window.__telemetry.snapshotData = snapshot;
window.__telemetry.snapshotComplete = true;
}
);
""")
def IsSnapshotComplete():
return self._runtime.Evaluate('window.__telemetry.snapshotComplete')
util.WaitFor(IsSnapshotComplete, timeout)
snap = self._runtime.Evaluate("""
(function() {
var data = window.__telemetry.snapshotData;
delete window.__telemetry.snapshotComplete;
delete window.__telemetry.snapshotData;
return data;
})()
""")
if snap:
return png_bitmap.PngBitmap(snap['data'])
return None
# Console public methods.
@property
def message_output_stream(self): # pylint: disable=E0202
return self._console.message_output_stream
@message_output_stream.setter
def message_output_stream(self, stream): # pylint: disable=E0202
self._console.message_output_stream = stream
# Memory public methods.
def GetDOMStats(self, timeout):
dom_counters = self._memory.GetDOMCounters(timeout)
return {
'document_count': dom_counters['documents'],
'node_count': dom_counters['nodes'],
'event_listener_count': dom_counters['jsEventListeners']
}
# Page public methods.
def PerformActionAndWaitForNavigate(self, action_function, timeout):
self._page.PerformActionAndWaitForNavigate(action_function, timeout)
def Navigate(self, url, script_to_evaluate_on_commit, timeout):
self._page.Navigate(url, script_to_evaluate_on_commit, timeout)
def GetCookieByName(self, name, timeout):
return self._page.GetCookieByName(name, timeout)
# Runtime public methods.
def ExecuteJavaScript(self, expr, timeout):
self._runtime.Execute(expr, timeout)
def EvaluateJavaScript(self, expr, timeout):
return self._runtime.Evaluate(expr, timeout)
# Timeline public methods.
@property
def timeline_model(self):
return self._timeline.timeline_model
def StartTimelineRecording(self):
self._timeline.Start()
def StopTimelineRecording(self):
self._timeline.Stop()
# Methods used internally by other backends.
def DispatchNotifications(self, timeout=10):
self._Connect()
self._SetTimeout(timeout)
try:
data = self._socket.recv()
except (socket.error, websocket.WebSocketException):
if self._browser_backend.tab_list_backend.DoesDebuggerUrlExist(
self._debugger_url):
return
raise exceptions.TabCrashException()
res = json.loads(data)
logging.debug('got [%s]', data)
if 'method' in res:
self._HandleNotification(res)
def _HandleNotification(self, res):
if (res['method'] == 'Inspector.detached' and
res.get('params', {}).get('reason','') == 'replaced_with_devtools'):
self._WaitForInspectorToGoAwayAndReconnect()
return
mname = res['method']
dot_pos = mname.find('.')
domain_name = mname[:dot_pos]
if domain_name in self._domain_handlers:
try:
self._domain_handlers[domain_name][0](res)
except Exception:
import traceback
traceback.print_exc()
else:
logging.debug('Unhandled inspector message: %s', res)
def SendAndIgnoreResponse(self, req):
self._Connect()
req['id'] = self._next_request_id
self._next_request_id += 1
data = json.dumps(req)
self._socket.send(data)
logging.debug('sent [%s]', data)
def _SetTimeout(self, timeout):
if self._cur_socket_timeout != timeout:
self._socket.settimeout(timeout)
self._cur_socket_timeout = timeout
def _WaitForInspectorToGoAwayAndReconnect(self):
sys.stderr.write('The connection to Chrome was lost to the Inspector UI.\n')
sys.stderr.write('Telemetry is waiting for the inspector to be closed...\n')
self._socket.close()
self._socket = None
def IsBack():
return self._browser_backend.tab_list_backend.DoesDebuggerUrlExist(
self._debugger_url)
util.WaitFor(IsBack, 512, 0.5)
sys.stderr.write('\n')
sys.stderr.write('Inspector\'s UI closed. Telemetry will now resume.\n')
self._Connect()
def SyncRequest(self, req, timeout=10):
self._Connect()
# TODO(nduca): Listen to the timeout argument
# pylint: disable=W0613
self._SetTimeout(timeout)
self.SendAndIgnoreResponse(req)
while True:
try:
data = self._socket.recv()
except (socket.error, websocket.WebSocketException):
if self._browser_backend.tab_list_backend.DoesDebuggerUrlExist(
self._debugger_url):
raise util.TimeoutException(
'Timed out waiting for reply. This is unusual.')
raise exceptions.TabCrashException()
res = json.loads(data)
logging.debug('got [%s]', data)
if 'method' in res:
self._HandleNotification(res)
continue
if res['id'] != req['id']:
logging.debug('Dropped reply: %s', json.dumps(res))
continue
return res
def RegisterDomain(self,
domain_name, notification_handler, will_close_handler):
"""Registers a given domain for handling notification methods.
For example, given inspector_backend:
def OnConsoleNotification(msg):
if msg['method'] == 'Console.messageAdded':
print msg['params']['message']
return
def OnConsoleClose(self):
pass
inspector_backend.RegisterDomain('Console',
OnConsoleNotification, OnConsoleClose)
"""
assert domain_name not in self._domain_handlers
self._domain_handlers[domain_name] = (notification_handler,
will_close_handler)
def UnregisterDomain(self, domain_name):
"""Unregisters a previously registered domain."""
assert domain_name in self._domain_handlers
self._domain_handlers.pop(domain_name)
| codenote/chromium-test | tools/telemetry/telemetry/core/chrome/inspector_backend.py | Python | bsd-3-clause | 9,767 | 0.009727 |
#!/usr/bin/python3
import rem_backend.query_data as qd
import rem_backend.propagation_model_estimation as pm
import threading
import _thread
__author__ = "Daniel Denkovski", "Valentin Rakovic"
__copyright__ = "Copyright (c) 2017, Faculty of Electrical Engineering and Information Technologies, UKIM, Skopje, Macedonia"
__version__ = "0.1.0"
__email__ = "{danield, valentin}@feit.ukim.edu.mk"
'''
REM console module
Showcases the REM backend capabilities of the extension
Used as console interface for users to interact with the platform
'''
def main():
run = 1;
while (run):
print("Please choose from the selection:")
print("1. WiFi device localization")
print("2. Duty cycle calculation")
print("3. Path loss model estimation")
print("0. Quit")
choice = input(" >> ")
if (choice == '0'):
run = 0
elif (choice == '1'):
print("Loc:Enter the channel of interest")
chann = input(" >> ")
dev_list = qd.get_all_active_devices_on_channel(chann,1)
try:
print("Select the index of the device of interest")
ind = 1
for row in dev_list:
print("{}. {}".format(ind,row[0]))
ind += 1
devind = input(" >> ")
print(dev_list[int(devind)-1][0])
try:
location = qd.estimate_tx_location(str(dev_list[int(devind)-1][0]),10)
print("The location of devices {} is:".format(str(dev_list[int(devind)-1][0])))
print("x:{} y:{} z:{} Pt:{} dBm".format(location[0],location[1],location[2],location[3]))
except:
print("not sufficient data for modeling")
print("")
except:
print("no devices")
print("")
elif (choice == '2'):
print("DC:Enter the channel of interest")
chann = input(" >> ")
ux, ul, dx, dy = input("provide ux ul dx dl coordinates of interest: ").split(' ')
try:
val = qd.get_duty_cycle_by_area(chann,10,ux,ul,dx,dy)
dc = val[0][0]
print("Duty cycle value for channel={} is {}".format(chann,dc))
except:
print("not sufficient data for modeling")
print("")
elif (choice == '3'):
print("PL:Enter the channel of interest")
chann = input(" >> ")
try:
val = pm.get_chann_model(10,chann)
print(val)
except:
print("not sufficient data for modeling")
print("")
if __name__=="__main__":
main()
| danieldUKIM/controllers_dockers | rem_console/REM_console.py | Python | apache-2.0 | 2,275 | 0.037528 |
"""
Support for Lutron lights.
For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/light.lutron/
"""
import logging
from homeassistant.components.light import (
ATTR_BRIGHTNESS, SUPPORT_BRIGHTNESS, Light)
from homeassistant.components.lutron import (
LutronDevice, LUTRON_DEVICES, LUTRON_CONTROLLER)
_LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['lutron']
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Lutron lights."""
devs = []
for (area_name, device) in hass.data[LUTRON_DEVICES]['light']:
dev = LutronLight(area_name, device, hass.data[LUTRON_CONTROLLER])
devs.append(dev)
add_entities(devs, True)
def to_lutron_level(level):
"""Convert the given HASS light level (0-255) to Lutron (0.0-100.0)."""
return float((level * 100) / 255)
def to_hass_level(level):
"""Convert the given Lutron (0.0-100.0) light level to HASS (0-255)."""
return int((level * 255) / 100)
class LutronLight(LutronDevice, Light):
"""Representation of a Lutron Light, including dimmable."""
def __init__(self, area_name, lutron_device, controller):
"""Initialize the light."""
self._prev_brightness = None
super().__init__(area_name, lutron_device, controller)
@property
def supported_features(self):
"""Flag supported features."""
return SUPPORT_BRIGHTNESS
@property
def brightness(self):
"""Return the brightness of the light."""
new_brightness = to_hass_level(self._lutron_device.last_level())
if new_brightness != 0:
self._prev_brightness = new_brightness
return new_brightness
def turn_on(self, **kwargs):
"""Turn the light on."""
if ATTR_BRIGHTNESS in kwargs and self._lutron_device.is_dimmable:
brightness = kwargs[ATTR_BRIGHTNESS]
elif self._prev_brightness == 0:
brightness = 255 / 2
else:
brightness = self._prev_brightness
self._prev_brightness = brightness
self._lutron_device.level = to_lutron_level(brightness)
def turn_off(self, **kwargs):
"""Turn the light off."""
self._lutron_device.level = 0
@property
def device_state_attributes(self):
"""Return the state attributes."""
attr = {'lutron_integration_id': self._lutron_device.id}
return attr
@property
def is_on(self):
"""Return true if device is on."""
return self._lutron_device.last_level() > 0
def update(self):
"""Call when forcing a refresh of the device."""
if self._prev_brightness is None:
self._prev_brightness = to_hass_level(self._lutron_device.level)
| PetePriority/home-assistant | homeassistant/components/lutron/light.py | Python | apache-2.0 | 2,793 | 0 |
import json as json_
# Template for code 200 requests so data can easily be added
def ok(d=None, *, json=True):
code = {'code': 200, 'status': 'OK', 'data': d}
if json:
code = json_.dumps(code)
return code
# The 400 codes shouldn't require any special aruments.
def invalid_request(*, json=True):
code = {'code': 400, 'status': 'MALFORMED_REQUEST'}
if json:
code = json_.dumps(code)
return code
def unknown_request(*, json=True):
code = {'code': 400, 'status': 'UNKNOWN_REQUEST'}
if json:
code = json_.dumps(code)
return code
# You can assign the internal server error a number for debugging purposes.
def internal_server_error(n=None, *, json=True):
status_string = 'INTERNAL_SERVER_ERROR'
if n is not None:
status_string += '_{}'.format(n)
code = {'code': 500, 'status': status_string}
if json:
code = json_.dumps(code)
return code
| TacticAlpha/basic-lan-webserver | server/status.py | Python | agpl-3.0 | 938 | 0 |
from bank_CI import BankCI
from bank_controller import BankController
from settings import DB_NAME, CREATE_TABLES, DROP_DATABASE
from sql_manager import BankDatabaseManager
def main():
manager = BankDatabaseManager.create_from_db_and_sql(DB_NAME, CREATE_TABLES, DROP_DATABASE, create_if_exists=False)
controller = BankController(manager)
command_interface = BankCI(controller)
command_interface.main_menu()
if __name__ == '__main__':
main()
| pepincho/Python101-and-Algo1-Courses | Programming-101-v3/week9/1-Money-In-The-Bank/start.py | Python | mit | 465 | 0.002151 |
# Major, Minor
VERSION = (1, 4) | duointeractive/python-bluefin | bluefin/__init__.py | Python | bsd-3-clause | 31 | 0.032258 |
# Copyright 2015 Internap.
#
# 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 warnings
from netman.core.objects.interface_states import OFF, ON
class BackwardCompatibleSwitchOperations(object):
"""
Depecrated methods
"""
def remove_access_vlan(self, interface_id):
warnings.warn("Deprecated, use unset_interface_access_vlan(interface_id) instead", DeprecationWarning)
return self.unset_interface_access_vlan(interface_id)
def configure_native_vlan(self, interface_id, vlan):
warnings.warn("Deprecated, use set_interface_native_vlan(interface_id, vlan) instead", DeprecationWarning)
return self.set_interface_native_vlan(interface_id, vlan)
def remove_native_vlan(self, interface_id):
warnings.warn("Deprecated, use unset_interface_native_vlan(interface_id) instead", DeprecationWarning)
return self.unset_interface_native_vlan(interface_id)
def remove_vlan_access_group(self, vlan_number, direction):
warnings.warn("Deprecated, use unset_vlan_access_group(vlan_number, direction) instead", DeprecationWarning)
return self.unset_vlan_access_group(vlan_number, direction)
def remove_vlan_vrf(self, vlan_number):
warnings.warn("Deprecated, use unset_vlan_vrf(vlan_number) instead", DeprecationWarning)
return self.unset_vlan_vrf(vlan_number)
def remove_interface_description(self, interface_id):
warnings.warn("Deprecated, use unset_interface_description(interface_id) instead", DeprecationWarning)
return self.unset_interface_description(interface_id)
def remove_bond_description(self, number):
warnings.warn("Deprecated, use unset_bond_description(number) instead", DeprecationWarning)
return self.unset_bond_description(number)
def configure_bond_native_vlan(self, number, vlan):
warnings.warn("Deprecated, use set_bond_native_vlan(number, vlan) instead", DeprecationWarning)
return self.set_bond_native_vlan(number, vlan)
def remove_bond_native_vlan(self, number):
warnings.warn("Deprecated, use unset_bond_native_vlan(number) instead", DeprecationWarning)
return self.unset_bond_native_vlan(number)
def enable_lldp(self, interface_id, enabled):
warnings.warn("Deprecated, use set_interface_lldp_state(interface_id, enabled) instead", DeprecationWarning)
return self.set_interface_lldp_state(interface_id, enabled)
def shutdown_interface(self, interface_id):
warnings.warn("Deprecated, use set_interface_state(interface_id, state) instead", DeprecationWarning)
return self.set_interface_state(interface_id, OFF)
def openup_interface(self, interface_id):
warnings.warn("Deprecated, use set_interface_state(interface_id, state) instead", DeprecationWarning)
return self.set_interface_state(interface_id, ON)
| internap/netman | netman/core/objects/backward_compatible_switch_operations.py | Python | apache-2.0 | 3,375 | 0.003556 |
#!/usr/bin/python
#
# Script to send email notifications when a change in Galera cluster membership
# occurs.
#
# Complies with http://www.codership.com/wiki/doku.php?id=notification_command
#
# Author: Gabe Guillen <gabeguillen@outlook.com>
# Version: 1.5
# Release: 3/5/2015
# Use at your own risk. No warranties expressed or implied.
#
import os
import sys
import getopt
import smtplib
try: from email.mime.text import MIMEText
except ImportError:
# Python 2.4 (CentOS 5.x)
from email.MIMEText import MIMEText
import socket
import email.utils
# Change this to some value if you don't want your server hostname to show in
# the notification emails
THIS_SERVER = socket.gethostname()
# Server hostname or IP address
SMTP_SERVER = 'YOUR_SMTP_HERE'
SMTP_PORT = 25
# Set to True if you need SMTP over SSL
SMTP_SSL = False
# Set to True if you need to authenticate to your SMTP server
SMTP_AUTH = False
# Fill in authorization information here if True above
SMTP_USERNAME = ''
SMTP_PASSWORD = ''
# Takes a single sender
MAIL_FROM = 'YOUR_EMAIL_HERE'
# Takes a list of recipients
MAIL_TO = ['SOME_OTHER_EMAIL_HERE']
# Need Date in Header for SMTP RFC Compliance
DATE = email.utils.formatdate()
# Edit below at your own risk
################################################################################
def main(argv):
str_status = ''
str_uuid = ''
str_primary = ''
str_members = ''
str_index = ''
message = ''
usage = "Usage: " + os.path.basename(sys.argv[0]) + " --status <status str>"
usage += " --uuid <state UUID> --primary <yes/no> --members <comma-seperated"
usage += " list of the component member UUIDs> --index <n>"
try:
opts, args = getopt.getopt(argv, "h", ["status=","uuid=",'primary=','members=','index='])
except getopt.GetoptError:
print usage
sys.exit(2)
if(len(opts) > 0):
message_obj = GaleraStatus(THIS_SERVER)
for opt, arg in opts:
if opt == '-h':
print usage
sys.exit()
elif opt in ("--status"):
message_obj.set_status(arg)
elif opt in ("--uuid"):
message_obj.set_uuid(arg)
elif opt in ("--primary"):
message_obj.set_primary(arg)
elif opt in ("--members"):
message_obj.set_members(arg)
elif opt in ("--index"):
message_obj.set_index(arg)
try:
send_notification(MAIL_FROM, MAIL_TO, 'Galera Notification: ' + THIS_SERVER, DATE,
str(message_obj), SMTP_SERVER, SMTP_PORT, SMTP_SSL, SMTP_AUTH,
SMTP_USERNAME, SMTP_PASSWORD)
except Exception, e:
print "Unable to send notification: %s" % e
sys.exit(1)
else:
print usage
sys.exit(2)
sys.exit(0)
def send_notification(from_email, to_email, subject, date, message, smtp_server,
smtp_port, use_ssl, use_auth, smtp_user, smtp_pass):
msg = MIMEText(message)
msg['From'] = from_email
msg['To'] = ', '.join(to_email)
msg['Subject'] = subject
msg['Date'] = date
if(use_ssl):
mailer = smtplib.SMTP_SSL(smtp_server, smtp_port)
else:
mailer = smtplib.SMTP(smtp_server, smtp_port)
if(use_auth):
mailer.login(smtp_user, smtp_pass)
mailer.sendmail(from_email, to_email, msg.as_string())
mailer.close()
class GaleraStatus:
def __init__(self, server):
self._server = server
self._status = ""
self._uuid = ""
self._primary = ""
self._members = ""
self._index = ""
self._count = 0
def set_status(self, status):
self._status = status
self._count += 1
def set_uuid(self, uuid):
self._uuid = uuid
self._count += 1
def set_primary(self, primary):
self._primary = primary.capitalize()
self._count += 1
def set_members(self, members):
self._members = members.split(',')
self._count += 1
def set_index(self, index):
self._index = index
self._count += 1
def __str__(self):
message = "Galera running on " + self._server + " has reported the following"
message += " cluster membership change"
if(self._count > 1):
message += "s"
message += ":\n\n"
if(self._status):
message += "Status of this node: " + self._status + "\n\n"
if(self._uuid):
message += "Cluster state UUID: " + self._uuid + "\n\n"
if(self._primary):
message += "Current cluster component is primary: " + self._primary + "\n\n"
if(self._members):
message += "Current members of the component:\n"
if(self._index):
for i in range(len(self._members)):
if(i == int(self._index)):
message += "-> "
else:
message += "-- "
message += self._members[i] + "\n"
else:
message += "\n".join((" " + str(x)) for x in self._members)
message += "\n"
if(self._index):
message += "Index of this node in the member list: " + self._index + "\n"
return message
if __name__ == "__main__":
main(sys.argv[1:])
| gguillen/galeranotify | galeranotify.py | Python | gpl-2.0 | 5,427 | 0.00387 |
# making a class callable:
class a(object):
def __init__(self, a):
print "__init__"
self.a = a
def __call__(self, *args):
print "__call__"
self.a = args[0]
# Based on this code, when we call a, the __init__ function gets called. My guess
# is that we dont have an instance initiallzed, then when we have an instance,
# we can call it
# Initallizing an obj
apple = a("Hello")
# Calling an obj
apple("Hi")
# What will this do? :
# @a
# def fuu(*args):
# print args
# fuu("hi")
| mr-uuid/snippets | python/classes/init_vs_call.py | Python | mit | 530 | 0.001887 |
#
# The MIT License (MIT)
#
# Copyright (c) 2016 Robert Hammelrath
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# Some parts of the software are a port of code provided by Rinky-Dink Electronics, Henning Karlsen,
# with the following copyright notice:
#
## Copyright (C)2015 Rinky-Dink Electronics, Henning Karlsen. All right reserved
## This library is free software; you can redistribute it and/or
## modify it under the terms of the CC BY-NC-SA 3.0 license.
## Please see the included documents for further information.
#
# Class supporting TFT LC-displays with a parallel Interface
# First example: Controller SSD1963 with a 4.3" or 7" display
#
# The minimal connection is:
# X1..X8 for data, Y9 for /Reset, Y10 for /RD, Y11 for /WR and Y12 for /RS
# Then LED must be hard tied to Vcc and /CS to GND.
#
import pyb, stm
from uctypes import addressof
from tft.driver import TFT_io
import gc
# define constants
#
RESET = const(1 << 10) ## Y9
RD = const(1 << 11) ## Y10
WR = const(0x01) ## Y11
D_C = const(0x02) ## Y12
LED = const(1 << 8) ## Y3
POWER = const(1 << 9) ## Y4
## CS is not used and must be hard tied to GND
PORTRAIT = const(1)
LANDSCAPE = const(0)
class TFT:
def __init__(self, controller = "SSD1963", lcd_type = "LB04301", orientation = LANDSCAPE,
v_flip = False, h_flip = False, power_control = True):
self.tft_init(controller, lcd_type, orientation, v_flip, h_flip)
def tft_init(self, controller = "SSD1963", lcd_type = "LB04301", orientation = LANDSCAPE,
v_flip = False, h_flip = False, power_control = True):
#
# For convenience, define X1..X1 and Y9..Y12 as output port using thy python functions.
# X1..X8 will be redefind on the fly as Input by accessing the MODER control registers
# when needed. Y9 is treate seperately, since it is used for Reset, which is done at python level
# since it need long delays anyhow, 5 and 15 ms vs. 10 µs.
#
# Set TFT general defaults
self.controller = controller
self.lcd_type = lcd_type
self.orientation = orientation
self.v_flip = v_flip # flip vertical
self.h_flip = h_flip # flip horizontal
self.c_flip = 0 # flip blue/red
self.rc_flip = 0 # flip row/column
self.setColor((255, 255, 255)) # set FG color to white as can be.
self.setBGColor((0, 0, 0)) # set BG to black
self.bg_buf = bytearray()
#
self.pin_led = None # deferred init Flag
self.power_control = power_control
if self.power_control:
# special treat for Power Pin
self.pin_power = pyb.Pin("Y4", pyb.Pin.OUT_PP)
self.power(True) ## switch Power on
#
pyb.delay(10)
# this may have to be moved to the controller specific section
if orientation == PORTRAIT:
self.setXY = TFT_io.setXY_P
self.drawPixel = TFT_io.drawPixel_P
else:
self.setXY = TFT_io.setXY_L
self.drawPixel = TFT_io.drawPixel_L
self.swapbytes = TFT_io.swapbytes
self.swapcolors = TFT_io.swapcolors
# ----------
for pin_name in ["X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8",
"Y10", "Y11", "Y12"]:
pin = pyb.Pin(pin_name, pyb.Pin.OUT_PP) # set as output
pin.value(1) ## set high as default
# special treat for Reset
self.pin_reset = pyb.Pin("Y9", pyb.Pin.OUT_PP)
# Reset the device
self.pin_reset.value(1) ## do a hard reset
pyb.delay(10)
self.pin_reset.value(0) ## Low
pyb.delay(20)
self.pin_reset.value(1) ## set high again
pyb.delay(20)
#
# Now initialiize the LCD
# This is for the SSD1963 controller and two specific LCDs. More may follow.
# Data taken from the SSD1963 data sheet, SSD1963 Application Note and the LCD Data sheets
#
if controller == "SSD1963": # 1st approach for 480 x 272
TFT_io.tft_cmd_data(0xe2, bytearray(b'\x1d\x02\x54'), 3) # PLL multiplier, set PLL clock to 100M
# N=0x2D for 6.5MHz, 0x1D for 10MHz crystal
# PLLClock = Crystal * (Mult + 1) / (Div + 1)
# The intermediate value Crystal * (Mult + 1) must be between 250MHz and 750 MHz
TFT_io.tft_cmd_data(0xe0, bytearray(b'\x01'), 1) # PLL Enable
pyb.delay(10)
TFT_io.tft_cmd_data(0xe0, bytearray(b'\x03'), 1)
pyb.delay(10)
TFT_io.tft_cmd(0x01) # software reset
pyb.delay(10)
#
# Settings for the LCD
#
# The LCDC_FPR depends on PLL clock and the reccomended LCD Dot clock DCLK
#
# LCDC_FPR = (DCLK * 1048576 / PLLClock) - 1
#
# The other settings are less obvious, since the definitions of the SSD1963 data sheet and the
# LCD data sheets differ. So what' common, even if the names may differ:
# HDP Horizontal Panel width (also called HDISP, Thd). The value store in the register is HDP - 1
# VDP Vertical Panel Width (also called VDISP, Tvd). The value stored in the register is VDP - 1
# HT Total Horizontal Period, also called HP, th... The exact value does not matter
# VT Total Vertical Period, alco called VT, tv, .. The exact value does not matter
# HPW Width of the Horizontal sync pulse, also called HS, thpw.
# VPW Width of the Vertical sync pulse, also called VS, tvpw
# Front Porch (HFP and VFP) Time between the end of display data and the sync pulse
# Back Porch (HBP and VBP Time between the start of the sync pulse and the start of display data.
# HT = FP + HDP + BP and VT = VFP + VDP + VBP (sometimes plus sync pulse width)
# Unfortunately, the controller does not use these front/back porch times, instead it uses an starting time
# in the front porch area and defines (see also figures in chapter 13.3 of the SSD1963 data sheet)
# HPS Time from that horiz. starting point to the start of the horzontal display area
# LPS Time from that horiz. starting point to the horizontal sync pulse
# VPS Time from the vert. starting point to the first line
# FPS Time from the vert. starting point to the vertical sync pulse
#
# So the following relations must be held:
#
# HT > HDP + HPS
# HPS >= HPW + LPS
# HPS = Back Porch - LPS, or HPS = Horizontal back Porch
# VT > VDP + VPS
# VPS >= VPW + FPS
# VPS = Back Porch - FPS, or VPS = Vertical back Porch
#
# LPS or FPS may have a value of zero, since the length of the front porch is detemined by the
# other figures
#
# The best is to start with the recomendations of the lCD data sheet for Back porch, grab a
# sync pulse with and the determine the other, such that they meet the relations. Typically, these
# values allow for some ambuigity.
#
if lcd_type == "LB04301": # Size 480x272, 4.3", 24 Bit, 4.3"
#
# Value Min Typical Max
# DotClock 5 MHZ 9 MHz 12 MHz
# HT (Hor. Total 490 531 612
# HDP (Hor. Disp) 480
# HBP (back porch) 8 43
# HFP (Fr. porch) 2 8
# HPW (Hor. sync) 1
# VT (Vert. Total) 275 288 335
# VDP (Vert. Disp) 272
# VBP (back porch) 2 12
# VFP (fr. porch) 1 4
# VPW (vert. sync) 1 10
#
# This table in combination with the relation above leads to the settings:
# HPS = 43, HPW = 8, LPS = 0, HT = 531
# VPS = 14, VPW = 10, FPS = 0, VT = 288
#
self.disp_x_size = 479
self.disp_y_size = 271
TFT_io.tft_cmd_data_AS(0xe6, bytearray(b'\x01\x70\xa3'), 3) # PLL setting for PCLK
# (9MHz * 1048576 / 100MHz) - 1 = 94371 = 0x170a3
TFT_io.tft_cmd_data_AS(0xb0, bytearray( # # LCD SPECIFICATION
[0x20, # 24 Color bits, HSync/VSync low, No Dithering
0x00, # TFT mode
self.disp_x_size >> 8, self.disp_x_size & 0xff, # physical Width of TFT
self.disp_y_size >> 8, self.disp_y_size & 0xff, # physical Height of TFT
0x00]), 7) # Last byte only required for a serial TFT
TFT_io.tft_cmd_data_AS(0xb4, bytearray(b'\x02\x13\x00\x2b\x08\x00\x00\x00'), 8)
# HSYNC, Set HT 531 HPS 43 HPW=Sync pulse 8 LPS 0
TFT_io.tft_cmd_data_AS(0xb6, bytearray(b'\x01\x20\x00\x0e\x0a\x00\x00'), 7)
# VSYNC, Set VT 288 VPS 14 VPW 10 FPS 0
TFT_io.tft_cmd_data_AS(0x36, bytearray([(orientation & 1) << 5 | (h_flip & 1) << 1 | (v_flip) & 1]), 1)
# rotation/ flip, etc., t.b.d.
elif lcd_type == "AT070TN92": # Size 800x480, 7", 18 Bit, lower color bits ignored
#
# Value Min Typical Max
# DotClock 26.4 MHz 33.3 MHz 46.8 MHz
# HT (Hor. Total 862 1056 1200
# HDP (Hor. Disp) 800
# HBP (back porch) 46 46 46
# HFP (Fr. porch) 16 210 254
# HPW (Hor. sync) 1 40
# VT (Vert. Total) 510 525 650
# VDP (Vert. Disp) 480
# VBP (back porch) 23 23 23
# VFP (fr. porch) 7 22 147
# VPW (vert. sync) 1 20
#
# This table in combination with the relation above leads to the settings:
# HPS = 46, HPW = 8, LPS = 0, HT = 1056
# VPS = 23, VPW = 10, VPS = 0, VT = 525
#
self.disp_x_size = 799
self.disp_y_size = 479
TFT_io.tft_cmd_data_AS(0xe6, bytearray(b'\x05\x53\xf6'), 3) # PLL setting for PCLK
# (33.3MHz * 1048576 / 100MHz) - 1 = 349174 = 0x553f6
TFT_io.tft_cmd_data_AS(0xb0, bytearray( # # LCD SPECIFICATION
[0x00, # 18 Color bits, HSync/VSync low, No Dithering/FRC
0x00, # TFT mode
self.disp_x_size >> 8, self.disp_x_size & 0xff, # physical Width of TFT
self.disp_y_size >> 8, self.disp_y_size & 0xff, # physical Height of TFT
0x00]), 7) # Last byte only required for a serial TFT
TFT_io.tft_cmd_data_AS(0xb4, bytearray(b'\x04\x1f\x00\x2e\x08\x00\x00\x00'), 8)
# HSYNC, Set HT 1056 HPS 46 HPW 8 LPS 0
TFT_io.tft_cmd_data_AS(0xb6, bytearray(b'\x02\x0c\x00\x17\x08\x00\x00'), 7)
# VSYNC, Set VT 525 VPS 23 VPW 08 FPS 0
TFT_io.tft_cmd_data_AS(0x36, bytearray([(orientation & 1) << 5 | (h_flip & 1) << 1 | (v_flip) & 1]), 1)
# rotation/ flip, etc., t.b.d.
else:
print("Wrong Parameter lcd_type: ", lcd_type)
return
TFT_io.tft_cmd_data_AS(0xBA, bytearray(b'\x0f'), 1) # GPIO[3:0] out 1
TFT_io.tft_cmd_data_AS(0xB8, bytearray(b'\x07\x01'), 1) # GPIO3=input, GPIO[2:0]=output
TFT_io.tft_cmd_data_AS(0xf0, bytearray(b'\x00'), 1) # Pixel data Interface 8 Bit
TFT_io.tft_cmd(0x29) # Display on
TFT_io.tft_cmd_data_AS(0xbe, bytearray(b'\x06\xf0\x01\xf0\x00\x00'), 6)
# Set PWM for B/L
TFT_io.tft_cmd_data_AS(0xd0, bytearray(b'\x0d'), 1) # Set DBC: enable, agressive
else:
print("Wrong Parameter controller: ", controller)
return
#
# Set character printing defaults
#
self.text_font = None
self.setTextStyle(self.color, self.BGcolor, 0, None, 0)
#
# Init done. clear Screen and switch BG LED on
#
self.text_x = self.text_y = self.text_yabs = 0
self.clrSCR() # clear the display
# self.backlight(100) ## switch BG LED on
#
# Return screen dimensions
#
def getScreensize(self):
if self.orientation == LANDSCAPE:
return (self.disp_x_size + 1, self.disp_y_size + 1)
else:
return (self.disp_y_size + 1, self.disp_x_size + 1)
#
# set backlight brightness
#
def backlight(self, percent):
# deferred init of LED PIN
if self.pin_led is None:
# special treat for BG LED
self.pin_led = pyb.Pin("Y3", pyb.Pin.OUT_PP)
self.led_tim = pyb.Timer(4, freq=500)
self.led_ch = self.led_tim.channel(3, pyb.Timer.PWM, pin=self.pin_led)
percent = max(0, min(percent, 100))
self.led_ch.pulse_width_percent(percent) # set LED
#
# switch power on/off
#
def power(self, onoff):
if self.power_control:
if onoff:
self.pin_power.value(True) ## switch power on or off
else:
self.pin_power.value(False)
#
# set the tft flip modes
#
def set_tft_mode(self, v_flip = False, h_flip = False, c_flip = False, orientation = LANDSCAPE):
self.v_flip = v_flip # flip vertical
self.h_flip = h_flip # flip horizontal
self.c_flip = c_flip # flip blue/red
self.orientation = orientation # LANDSCAPE/PORTRAIT
TFT_io.tft_cmd_data_AS(0x36,
bytearray([(self.orientation << 5) |(self.c_flip << 3) | (self.h_flip & 1) << 1 | (self.v_flip) & 1]), 1)
# rotation/ flip, etc., t.b.d.
#
# get the tft flip modes
#
def get_tft_mode(self):
return (self.v_flip, self.h_flip, self.c_flip, self.orientation) #
#
# set the color used for the draw commands
#
def setColor(self, fgcolor):
self.color = fgcolor
self.colorvect = bytearray(self.color) # prepare byte array
#
# Set BG color used for the draw commands
#
def setBGColor(self, bgcolor):
self.BGcolor = bgcolor
self.BGcolorvect = bytearray(self.BGcolor) # prepare byte array
self.BMPcolortable = bytearray([self.BGcolorvect[2], # create colortable
self.BGcolorvect[1], self.BGcolorvect[0],0,
self.colorvect[2], self.colorvect[1], self.colorvect[0],0])
#
# get the color used for the draw commands
#
def getColor(self):
return self.color
#
# get BG color used for
#
def getBGColor(self):
return self.BGcolor
#
# Draw a single pixel at location x, y with color
# Rather slow at 40µs/Pixel
#
def drawPixel_py(self, x, y, color):
self.setXY(x, y, x, y)
TFT_io.displaySCR_AS(color, 1) #
#
# clear screen, set it to BG color.
#
def clrSCR(self, color = None):
colorvect = self.BGcolorvect if color is None else bytearray(color)
self.clrXY()
TFT_io.fillSCR_AS(colorvect, (self.disp_x_size + 1) * (self.disp_y_size + 1))
self.setScrollArea(0, self.disp_y_size + 1, 0)
self.setScrollStart(0)
self.setTextPos(0,0)
#
# reset the address range to fullscreen
#
def clrXY(self):
if self.orientation == LANDSCAPE:
self.setXY(0, 0, self.disp_x_size, self.disp_y_size)
else:
self.setXY(0, 0, self.disp_y_size, self.disp_x_size)
#
# Draw a line from x1, y1 to x2, y2 with the color set by setColor()
# Straight port from the UTFT Library at Rinky-Dink Electronics
#
def drawLine(self, x1, y1, x2, y2, color = None):
if y1 == y2:
self.drawHLine(x1, y1, x2 - x1 + 1, color)
elif x1 == x2:
self.drawVLine(x1, y1, y2 - y1 + 1, color)
else:
colorvect = self.colorvect if color is None else bytearray(color)
dx, xstep = (x2 - x1, 1) if x2 > x1 else (x1 - x2, -1)
dy, ystep = (y2 - y1, 1) if y2 > y1 else (y1 - y2, -1)
col, row = x1, y1
if dx < dy:
t = - (dy >> 1)
while True:
self.drawPixel(col, row, colorvect)
if row == y2:
return
row += ystep
t += dx
if t >= 0:
col += xstep
t -= dy
else:
t = - (dx >> 1)
while True:
self.drawPixel(col, row, colorvect)
if col == x2:
return
col += xstep
t += dy
if t >= 0:
row += ystep
t -= dx
#
# Draw a horizontal line with 1 Pixel width, from x,y to x + l - 1, y
# Straight port from the UTFT Library at Rinky-Dink Electronics
#
def drawHLine(self, x, y, l, color = None): # draw horiontal Line
colorvect = self.colorvect if color is None else bytearray(color)
if l < 0: # negative length, swap parameters
l = -l
x -= l
self.setXY(x, y, x + l - 1, y) # set display window
TFT_io.fillSCR_AS(colorvect, l)
#
# Draw a vertical line with 1 Pixel width, from x,y to x, y + l - 1
# Straight port from the UTFT Library at Rinky-Dink Electronics
#
def drawVLine(self, x, y, l, color = None): # draw horiontal Line
colorvect = self.colorvect if color is None else bytearray(color)
if l < 0: # negative length, swap parameters
l = -l
y -= l
self.setXY(x, y, x, y + l - 1) # set display window
TFT_io.fillSCR_AS(colorvect, l)
#
# Draw rectangle from x1, y1, to x2, y2
# Straight port from the UTFT Library at Rinky-Dink Electronics
#
def drawRectangle(self, x1, y1, x2, y2, color = None):
if x1 > x2:
x1, x2 = x2, x1
if y1 > y2:
y1, y2 = y2, y1
self.drawHLine(x1, y1, x2 - x1 + 1, color)
self.drawHLine(x1, y2, x2 - x1 + 1, color)
self.drawVLine(x1, y1, y2 - y1 + 1, color)
self.drawVLine(x2, y1, y2 - y1 + 1, color)
#
# Fill rectangle
# Almost straight port from the UTFT Library at Rinky-Dink Electronics
#
def fillRectangle(self, x1, y1, x2, y2, color=None):
if x1 > x2:
x1, x2 = x2, x1
if y1 > y2:
y1, y2 = y2, y1
self.setXY(x1, y1, x2, y2) # set display window
if color:
TFT_io.fillSCR_AS(bytearray(color), (x2 - x1 + 1) * (y2 - y1 + 1))
else:
TFT_io.fillSCR_AS(self.colorvect, (x2 - x1 + 1) * (y2 - y1 + 1))
#
# Draw smooth rectangle from x1, y1, to x2, y2
# Straight port from the UTFT Library at Rinky-Dink Electronics
#
def drawClippedRectangle(self, x1, y1, x2, y2, color = None):
if x1 > x2:
x1, x2 = x2, x1
if y1 > y2:
y1, y2 = y2, y1
if (x2-x1) > 4 and (y2-y1) > 4:
colorvect = self.colorvect if color is None else bytearray(color)
self.drawPixel(x1 + 2,y1 + 1, colorvect)
self.drawPixel(x1 + 1,y1 + 2, colorvect)
self.drawPixel(x2 - 2,y1 + 1, colorvect)
self.drawPixel(x2 - 1,y1 + 2, colorvect)
self.drawPixel(x1 + 2,y2 - 1, colorvect)
self.drawPixel(x1 + 1,y2 - 2, colorvect)
self.drawPixel(x2 - 2,y2 - 1, colorvect)
self.drawPixel(x2 - 1,y2 - 2, colorvect)
self.drawHLine(x1 + 3, y1, x2 - x1 - 5, colorvect)
self.drawHLine(x1 + 3, y2, x2 - x1 - 5, colorvect)
self.drawVLine(x1, y1 + 3, y2 - y1 - 5, colorvect)
self.drawVLine(x2, y1 + 3, y2 - y1 - 5, colorvect)
#
# Fill smooth rectangle from x1, y1, to x2, y2
# Straight port from the UTFT Library at Rinky-Dink Electronics
#
def fillClippedRectangle(self, x1, y1, x2, y2, color = None):
if x1 > x2:
t = x1; x1 = x2; x2 = t
if y1 > y2:
t = y1; y1 = y2; y2 = t
if (x2-x1) > 4 and (y2-y1) > 4:
for i in range(((y2 - y1) // 2) + 1):
if i == 0:
self.drawHLine(x1 + 3, y1 + i, x2 - x1 - 5, color)
self.drawHLine(x1 + 3, y2 - i, x2 - x1 - 5, color)
elif i == 1:
self.drawHLine(x1 + 2, y1 + i, x2 - x1 - 3, color)
self.drawHLine(x1 + 2, y2 - i, x2 - x1 - 3, color)
elif i == 2:
self.drawHLine(x1 + 1, y1 + i, x2 - x1 - 1, color)
self.drawHLine(x1 + 1, y2 - i, x2 - x1 - 1, color)
else:
self.drawHLine(x1, y1 + i, x2 - x1 + 1, color)
self.drawHLine(x1, y2 - i, x2 - x1 + 1, color)
#
# draw a circle at x, y with radius
# Straight port from the UTFT Library at Rinky-Dink Electronics
#
def drawCircle(self, x, y, radius, color = None):
colorvect = self.colorvect if color is None else bytearray(color)
f = 1 - radius
ddF_x = 1
ddF_y = -2 * radius
x1 = 0
y1 = radius
self.drawPixel(x, y + radius, colorvect)
self.drawPixel(x, y - radius, colorvect)
self.drawPixel(x + radius, y, colorvect)
self.drawPixel(x - radius, y, colorvect)
while x1 < y1:
if f >= 0:
y1 -= 1
ddF_y += 2
f += ddF_y
x1 += 1
ddF_x += 2
f += ddF_x
self.drawPixel(x + x1, y + y1, colorvect)
self.drawPixel(x - x1, y + y1, colorvect)
self.drawPixel(x + x1, y - y1, colorvect)
self.drawPixel(x - x1, y - y1, colorvect)
self.drawPixel(x + y1, y + x1, colorvect)
self.drawPixel(x - y1, y + x1, colorvect)
self.drawPixel(x + y1, y - x1, colorvect)
self.drawPixel(x - y1, y - x1, colorvect)
#
# fill a circle at x, y with radius
# Straight port from the UTFT Library at Rinky-Dink Electronics
# Instead of calculating x = sqrt(r*r - y*y), it searches the x
# for r*r = x*x + x*x
#
def fillCircle(self, x, y, radius, color = None):
r_square = radius * radius * 4
for y1 in range (-(radius * 2), 1):
y_square = y1 * y1
for x1 in range (-(radius * 2), 1):
if x1*x1+y_square <= r_square:
x1i = x1 // 2
y1i = y1 // 2
self.drawHLine(x + x1i, y + y1i, 2 * (-x1i), color)
self.drawHLine(x + x1i, y - y1i, 2 * (-x1i), color)
break;
#
# Draw a bitmap at x,y with size sx, sy
# mode determines the type of expected data
# mode = 1: The data contains 1 bit per pixel, mapped to fg/bg color
# unless a colortable is provided
# mode = 2: The data contains 2 bit per pixel; a colortable with 4 entries must be provided
# mode = 4: The data contains 4 bit per pixel;
# a colortable with 16 entries must be provided
# mode = 8: The data contains 8 bit per pixel;
# a colortable with 256 entries must be provided
# mode = 16: The data must contain 2 packed bytes/pixel red/green/blue in 565 format
# mode = 24: The data must contain 3 bytes/pixel red/green/blue
#
def drawBitmap(self, x, y, sx, sy, data, mode = 24, colortable = None):
self.setXY(x, y, x + sx - 1, y + sy - 1)
if mode == 24:
TFT_io.displaySCR_AS(data, sx * sy)
elif mode == 16:
TFT_io.displaySCR565_AS(data, sx * sy)
elif mode == 1:
if colortable is None:
colortable = self.BMPcolortable # create colortable
TFT_io.displaySCR_bmp(data, sx*sy, 1, colortable)
elif mode == 2:
if colortable is None:
return
TFT_io.displaySCR_bmp(data, sx*sy, 2, colortable)
elif mode == 4:
if colortable is None:
return
TFT_io.displaySCR_bmp(data, sx*sy, 4, colortable)
elif mode == 8:
if colortable is None:
return
TFT_io.displaySCR_bmp(data, sx*sy, 8, colortable)
#
# set scroll area to the region between the first and last line
#
def setScrollArea(self, tfa, vsa, bfa):
TFT_io.tft_cmd_data_AS(0x33, bytearray( #set scrolling range
[(tfa >> 8) & 0xff, tfa & 0xff,
(vsa >> 8) & 0xff, vsa & 0xff,
(bfa >> 8) & 0xff, bfa & 0xff]), 6)
self.scroll_tfa = tfa
self.scroll_vsa = vsa
self.scroll_bfa = bfa
self.setScrollStart(self.scroll_tfa)
x, y = self.getTextPos()
self.setTextPos(x, y) # realign pointers
#
# get scroll area of the region between the first and last line
#
def getScrollArea(self):
return self.scroll_tfa, self.scroll_vsa, self.scroll_bfa
#
# set the line which is displayed first
#
def setScrollStart(self, lline):
self.scroll_start = lline # store the logical first line
TFT_io.tft_cmd_data_AS(0x37, bytearray([(lline >> 8) & 0xff, lline & 0xff]), 2)
#
# get the line which is displayed first
#
def getScrollStart(self):
return self.scroll_start # get the logical first line
#
# Scroll vsa up/down by a number of pixels
#
def scroll(self, pixels):
line = ((self.scroll_start - self.scroll_tfa + pixels) % self.scroll_vsa
+ self.scroll_tfa)
self.setScrollStart(line) # set the new line
#
# Set text position
#
def setTextPos(self, x, y, clip = False, scroll = True):
self.text_width, self.text_height = self.getScreensize() ## height possibly wrong
self.text_x = x
if self.scroll_tfa <= y < (self.scroll_tfa + self.scroll_vsa): # in scroll area ? check later for < or <=
# correct position relative to scroll start
self.text_y = (y + self.scroll_start - self.scroll_tfa)
if self.text_y >= (self.scroll_tfa + self.scroll_vsa):
self.text_y -= self.scroll_vsa
else: # absolute
self.text_y = y
self.text_yabs = y
# Hint: self.text_yabs = self.text_y - self.scroll_start) % self.scroll_vsa + self.scroll_tfa)
if clip and (self.text_x + clip) < self.text_width:
self.text_width = self.text_x + clip
self.text_scroll = scroll
#
# Get text position
#
def getTextPos(self, abs = True):
if abs:
return (self.text_x, self.text_yabs)
else:
return (self.text_x, self.text_y)
#
# Set Text Style
#
def setTextStyle(self, fgcolor=None, bgcolor=None, transparency=None, font=None, gap=None):
if font is not None:
self.text_font = font
self.text_rows = font.height()
self.text_cols = font.max_width()
if transparency is not None:
self.transparency = transparency
if gap is not None:
self.text_gap = gap
if bgcolor is not None:
self.text_bgcolor = bgcolor
if fgcolor is not None:
self.text_fgcolor = fgcolor
self.text_color = (bytearray(self.text_bgcolor)
+ bytearray(self.text_fgcolor)
+ bytearray([self.transparency]))
#
# Get Text Style: return (color, bgcolor, font, transpareny, gap)
#
def getTextStyle(self):
return (self.text_color[3:6], self.text_color[0:3],
self.transparency, self.text_font, self.text_gap)
#
# Check, if a new line is to be opened
# if yes, advance, including scrolling, and clear line, if flags is set
# Obsolete?
#
def printNewline(self, clear = False):
if (self.text_yabs + self.text_rows) >= (self.scroll_tfa + self.scroll_vsa): # does the line fit?
self.scroll(self.text_rows) # no. scroll
else: # Yes, just advance pointers
self.text_yabs += self.text_rows
self.setTextPos(self.text_x, self.text_yabs)
if clear:
self.printClrLine(2) # clear actual line
#
# Carriage Return
#
def printCR(self): # clear to end of line
self.text_x = 0
#
# clear line modes
#
def printClrLine(self, mode = 0): # clear to end of line/bol/line
if mode == 0:
self.setXY(self.text_x, self.text_y,
self.text_width - 1, self.text_y + self.text_rows - 1) # set display window
TFT_io.fillSCR_AS(self.text_color, (self.text_width - self.text_x + 1) * self.text_rows)
elif mode == 1 and self.text_x > 0:
self.setXY(0, self.text_y,
self.text_x - 1, self.text_y + self.text_rows - 1) # set display window
TFT_io.fillSCR_AS(self.text_color, (self.text_x - 1) * self.text_rows)
elif mode == 2:
self.setXY(0, self.text_y,
self.text_width - 1, self.text_y + self.text_rows - 1) # set display window
TFT_io.fillSCR_AS(self.text_color, self.text_width * self.text_rows)
#
# clear sreen modes
#
def printClrSCR(self): # clear Area set by setScrollArea
self.setXY(0, self.scroll_tfa,
self.text_width - 1, self.scroll_tfa + self.scroll_vsa) # set display window
TFT_io.fillSCR_AS(self.text_color, self.text_width * self.scroll_vsa)
self.setScrollStart(self.scroll_tfa)
self.setTextPos(0, self.scroll_tfa)
#
# Print string s, returning the length of the printed string in pixels
#
def printString(self, s, bg_buf=None):
len = 0
for c in s:
cols = self.printChar(c, bg_buf)
if cols == 0: # could not print (any more)
break
len += cols
return len
#
# Print string c using the given char bitmap at location x, y, returning the width of the printed char in pixels
#
def printChar(self, c, bg_buf=None):
# get the charactes pixel bitmap and dimensions
if self.text_font:
fmv, rows, cols = self.text_font.get_ch(c)
else:
raise AttributeError('No font selected')
cbytes, cbits = divmod(cols, 8) # Not in packed format
dcols = (cbytes + 1) * 8 if cbits else cbytes * 8 # cols for display
pix_count = dcols * rows # number of bits in the char
# test char fit
if self.text_x + cols > self.text_width: # does the char fit on the screen?
if self.text_scroll:
self.printCR() # No, then CR
self.printNewline(True) # NL: advance to the next line
else:
return 0
# Retrieve Background data if transparency is required
if self.transparency: # in case of transpareny, the frame buffer content is needed
if bg_buf is None: # buffer allocation needed?
if len(self.bg_buf) < pix_count * 3:
del(self.bg_buf)
gc.collect()
self.bg_buf = bytearray(pix_count * 3) # Make it bigger
bg_buf = self.bg_buf
self.setXY(self.text_x, self.text_y, self.text_x + dcols - 1, self.text_y + rows - 1) # set area
TFT_io.tft_read_cmd_data_AS(0x2e, bg_buf, pix_count * 3) # read background data
else:
bg_buf = 0 # dummy assignment, since None is not accepted
# Set XY range & print char
self.setXY(self.text_x, self.text_y, self.text_x + dcols - 1, self.text_y + rows - 1) # set area
TFT_io.displaySCR_charbitmap(addressof(fmv), pix_count, self.text_color, bg_buf) # display char!
#advance pointer
self.text_x += (cols + self.text_gap)
return cols + self.text_gap
| peterhinch/micropython-tft-gui | tft/driver/tft.py | Python | mit | 32,591 | 0.010034 |
# -*- coding: utf-8 -*-
from scrapy.spiders import Rule
from scrapy.linkextractors import LinkExtractor
from scrapy_redis.spiders import RedisCrawlSpider
class BaiduSpider(RedisCrawlSpider):
"""Spider that reads urls from redis queue (myspider:start_urls)."""
name = 'baidu'
redis_key = 'crawler:start_keyword'
"""Spider that reads urls from redis queue when idle."""
rules = (
Rule(LinkExtractor("baidu.php"), callback='parse_page', follow=True),
)
def __init__(self, *args, **kwargs):
# Dynamically define the allowed domains list.
domain = kwargs.pop('domain', '')
self.allowed_domains = filter(None, domain.split(','))
super(BaiduSpider, self).__init__(*args, **kwargs)
def parse_page(self, response):
data = {
'name': response.css('title::text').extract_first(),
'url': response.url,
}
import pprint
pprint.pprint(data)
return data
| scrapycloud/scrapy-cluster | crawler/crawler/spiders/baidu.py | Python | mit | 979 | 0.002043 |
# -*- coding: utf-8 -*-
#
# Copyright 2012-2015 Spotify AB
#
# 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.
#
"""
Locking functionality when launching things from the command line.
Uses a pidfile.
This prevents multiple identical workflows to be launched simultaneously.
"""
from __future__ import print_function
import hashlib
import os
from luigi import six
def getpcmd(pid):
"""
Returns command of process.
:param pid:
"""
cmd = 'ps -p %s -o command=' % (pid,)
with os.popen(cmd, 'r') as p:
return p.readline().strip()
def get_info(pid_dir, my_pid=None):
# Check the name and pid of this process
if my_pid is None:
my_pid = os.getpid()
my_cmd = getpcmd(my_pid)
if six.PY3:
cmd_hash = my_cmd.encode('utf8')
else:
cmd_hash = my_cmd
pid_file = os.path.join(pid_dir, hashlib.md5(cmd_hash).hexdigest()) + '.pid'
return my_pid, my_cmd, pid_file
def acquire_for(pid_dir, num_available=1):
"""
Makes sure the process is only run once at the same time with the same name.
Notice that we since we check the process name, different parameters to the same
command can spawn multiple processes at the same time, i.e. running
"/usr/bin/my_process" does not prevent anyone from launching
"/usr/bin/my_process --foo bar".
"""
my_pid, my_cmd, pid_file = get_info(pid_dir)
# Check if there is a pid file corresponding to this name
if not os.path.exists(pid_dir):
os.mkdir(pid_dir)
os.chmod(pid_dir, 0o777)
pids = set()
pid_cmds = {}
if os.path.exists(pid_file):
# There is such a file - read the pid and look up its process name
pids.update(filter(None, map(str.strip, open(pid_file))))
pid_cmds = dict((pid, getpcmd(pid)) for pid in pids)
matching_pids = list(filter(lambda pid: pid_cmds[pid] == my_cmd, pids))
if len(matching_pids) >= num_available:
# We are already running under a different pid
print('Pid(s)', ', '.join(matching_pids), 'already running')
return False
else:
# The pid belongs to something else, we could
pass
pid_cmds[str(my_pid)] = my_cmd
# Write pids
pids.add(str(my_pid))
with open(pid_file, 'w') as f:
f.writelines('%s\n' % (pid, ) for pid in filter(pid_cmds.__getitem__, pids))
# Make the file writable by all
if os.name == 'nt':
pass
else:
s = os.stat(pid_file)
if os.getuid() == s.st_uid:
os.chmod(pid_file, s.st_mode | 0o777)
return True
| torypages/luigi | luigi/lock.py | Python | apache-2.0 | 3,102 | 0.001289 |
#!/usr/bin/env python
"""alerts.py Classes for sendings alerts
"""
__author__ = "Jean-Martin Archer"
__copyright__ = "Copyright 2013, MIT License."
import smtplib
from twilio.rest import TwilioRestClient
from vendors.pushbullet.pushbullet import PushBullet
import configuration
class Alerts(object):
"""<ac:image ac:thumbnail="true" ac:width="300">for alerts"""
def __init__(self, config_path='./config/'):
self.config = configuration.load(config_path)
self.register()
def register(self):
alerts = self.config['alerts']
alerts_list = []
if alerts['sms']['on']:
alerts_list.append(alerts.sms(alerts['AlertSMS']))
if alerts['pushbullet']['on']:
alerts_list.append(alerts.pushbullet(alerts['AlertPushBullet']))
if alerts['email']['on']:
alerts_list.append(alerts.sms(alerts['AlertPushBullet']))
self.alerts = alerts_list
def send(self, message):
for alert in self.alerts:
alert.send_notification(message)
class BasicAlert(object):
"""<ac:image ac:thumbnail="true" ac:width="300">for BasicAlert class. This is more an interface/contract
than anything else"""
def __init__(self, config):
self.config = config
self.setup()
def setup(self):
raise NotImplementedError
def send_notification(self, message):
raise NotImplementedError
class AlertEmail(BasicAlert):
"""<ac:image ac:thumbnail="true" ac:width="300">for AlertEmail"""
def setup(self):
self.sender = self.config['email_sender']
self.receivers = self.config['email_receivers']
self.server = self.config['server']
def send_notification(self, message):
email_body = """From: Alert <%s>
To: Alert <%s>
Subject: %s
This is a test e-mail message.
""" % (self.sender, self.receivers, message)
try:
smtpObj = smtplib.SMTP(self.server)
smtpObj.sendmail(self.sender, self.receivers, email_body)
print "Successfully sent AlertEmail"
except SMTPException:
print "Error: unable to send AlertEmail"
class AlertPushBullet(BasicAlert):
"""<ac:image ac:thumbnail="true" ac:width="300">for AlertPushBullet. Get you api key from
https://www.PushBullet.com/account
Use the pyPushBullet API to know which deviceID to use.
"""
def setup(self):
self.push = PushBullet(self.config['apikey'])
def send_notification(self, message):
for device in self.config['device']:
self.push.pushNote(device, message, message)
def get_device_id(self):
print self.push.getDevices()
class AlertSMS(BasicAlert):
"""<ac:image ac:thumbnail="true" ac:width="300">for AlertSMS, uses your twilio.com account."""
def setup(self):
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = self.config['twilio_sid']
auth_token = self.config['twilio_auth_token']
self.client = TwilioRestClient(account_sid, auth_token)
self.create = client.sms.messages.create
def send_notification(self, message):
message = self.create(body=message,
to=self.config['to_number'],
from_=self.config["from_number"])
| j-martin/raspberry-gpio-zmq | raspzmq/alerts.py | Python | mit | 3,371 | 0.00089 |
# coding=utf-8
# Copyright 2014 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
unicode_literals, with_statement)
import itertools
import os
import subprocess
from collections import OrderedDict
from hashlib import sha1
from twitter.common.collections import OrderedSet
from pants.backend.codegen.targets.java_protobuf_library import JavaProtobufLibrary
from pants.backend.codegen.tasks.protobuf_parse import ProtobufParse
from pants.backend.codegen.tasks.simple_codegen_task import SimpleCodegenTask
from pants.backend.jvm.targets.jar_library import JarLibrary
from pants.backend.jvm.targets.java_library import JavaLibrary
from pants.backend.jvm.tasks.jar_import_products import JarImportProducts
from pants.base.address import Address
from pants.base.build_environment import get_buildroot
from pants.base.exceptions import TaskError
from pants.base.source_root import SourceRoot
from pants.binaries.binary_util import BinaryUtil
from pants.fs.archive import ZIP
from pants.util.dirutil import safe_mkdir
from pants.util.memo import memoized_property
class ProtobufGen(SimpleCodegenTask):
@classmethod
def global_subsystems(cls):
return super(ProtobufGen, cls).global_subsystems() + (BinaryUtil.Factory,)
@classmethod
def register_options(cls, register):
super(ProtobufGen, cls).register_options(register)
# The protoc version and the plugin names are used as proxies for the identity of the protoc
# executable environment here. Although version is an obvious proxy for the protoc binary
# itself, plugin names are less so and plugin authors must include a version in the name for
# proper invalidation of protobuf products in the face of plugin modification that affects
# plugin outputs.
register('--version', advanced=True, fingerprint=True,
help='Version of protoc. Used to create the default --javadeps and as part of '
'the path to lookup the tool with --pants-support-baseurls and '
'--pants-bootstrapdir. When changing this parameter you may also need to '
'update --javadeps.',
default='2.4.1')
register('--plugins', advanced=True, fingerprint=True, action='append',
help='Names of protobuf plugins to invoke. Protoc will look for an executable '
'named protoc-gen-$NAME on PATH.',
default=[])
register('--extra_path', advanced=True, action='append',
help='Prepend this path onto PATH in the environment before executing protoc. '
'Intended to help protoc find its plugins.',
default=None)
register('--supportdir', advanced=True,
help='Path to use for the protoc binary. Used as part of the path to lookup the'
'tool under --pants-bootstrapdir.',
default='bin/protobuf')
register('--javadeps', advanced=True, action='append',
help='Dependencies to bootstrap this task for generating java code. When changing '
'this parameter you may also need to update --version.',
default=['3rdparty:protobuf-java'])
# TODO https://github.com/pantsbuild/pants/issues/604 prep start
@classmethod
def prepare(cls, options, round_manager):
super(ProtobufGen, cls).prepare(options, round_manager)
round_manager.require_data(JarImportProducts)
round_manager.require_data('deferred_sources')
# TODO https://github.com/pantsbuild/pants/issues/604 prep finish
def __init__(self, *args, **kwargs):
"""Generates Java files from .proto files using the Google protobuf compiler."""
super(ProtobufGen, self).__init__(*args, **kwargs)
self.plugins = self.get_options().plugins
self._extra_paths = self.get_options().extra_path
@memoized_property
def protobuf_binary(self):
binary_util = BinaryUtil.Factory.create()
return binary_util.select_binary(self.get_options().supportdir,
self.get_options().version,
'protoc')
@property
def javadeps(self):
return self.resolve_deps(self.get_options().javadeps)
@property
def synthetic_target_type(self):
return JavaLibrary
def synthetic_target_extra_dependencies(self, target):
deps = OrderedSet()
if target.imported_jars:
# We need to add in the proto imports jars.
jars_address = Address(os.path.relpath(self.codegen_workdir(target), get_buildroot()),
target.id + '-rjars')
jars_target = self.context.add_new_target(jars_address,
JarLibrary,
jars=target.imported_jars,
derived_from=target)
deps.update([jars_target])
deps.update(self.javadeps)
return deps
def is_gentarget(self, target):
return isinstance(target, JavaProtobufLibrary)
@classmethod
def supported_strategy_types(cls):
return [cls.IsolatedCodegenStrategy, cls.ProtobufGlobalCodegenStrategy]
def sources_generated_by_target(self, target):
genfiles = []
for source in target.sources_relative_to_source_root():
path = os.path.join(target.target_base, source)
genfiles.extend(self.calculate_genfiles(path, source))
return genfiles
def execute_codegen(self, targets):
if not targets:
return
sources_by_base = self._calculate_sources(targets)
if self.codegen_strategy.name() == 'isolated':
sources = OrderedSet()
for target in targets:
sources.update(target.sources_relative_to_buildroot())
else:
sources = OrderedSet(itertools.chain.from_iterable(sources_by_base.values()))
if not self.validate_sources_present(sources, targets):
return
bases = OrderedSet(sources_by_base.keys())
bases.update(self._proto_path_imports(targets))
check_duplicate_conflicting_protos(self, sources_by_base, sources, self.context.log)
for target in targets:
# NB(gm): If the strategy is set to 'isolated', then 'targets' should contain only a single
# element, which means this simply sets the output directory depending on that element.
# If the strategy is set to 'global', the target passed in as a parameter here will be
# completely arbitrary, but that's OK because the codegen_workdir function completely
# ignores the target parameter when using a global strategy.
output_dir = self.codegen_workdir(target)
break
gen_flag = '--java_out'
safe_mkdir(output_dir)
gen = '{0}={1}'.format(gen_flag, output_dir)
args = [self.protobuf_binary, gen]
if self.plugins:
for plugin in self.plugins:
# TODO(Eric Ayers) Is it a good assumption that the generated source output dir is
# acceptable for all plugins?
args.append("--{0}_out={1}".format(plugin, output_dir))
for base in bases:
args.append('--proto_path={0}'.format(base))
args.extend(sources)
# Tack on extra path entries. These can be used to find protoc plugins
protoc_environ = os.environ.copy()
if self._extra_paths:
protoc_environ['PATH'] = os.pathsep.join(self._extra_paths
+ protoc_environ['PATH'].split(os.pathsep))
self.context.log.debug('Executing: {0}'.format('\\\n '.join(args)))
process = subprocess.Popen(args, env=protoc_environ)
result = process.wait()
if result != 0:
raise TaskError('{0} ... exited non-zero ({1})'.format(self.protobuf_binary, result))
def _calculate_sources(self, targets):
gentargets = OrderedSet()
def add_to_gentargets(target):
if self.is_gentarget(target):
gentargets.add(target)
self.context.build_graph.walk_transitive_dependency_graph(
[target.address for target in targets],
add_to_gentargets,
postorder=True)
sources_by_base = OrderedDict()
# TODO(Eric Ayers) Extract this logic for general use? When using unpacked_jars it is needed
# to get the correct source root for paths outside the current BUILD tree.
for target in gentargets:
for source in target.sources_relative_to_buildroot():
base = SourceRoot.find_by_path(source)
if not base:
base, _ = target.target_base, target.sources_relative_to_buildroot()
self.context.log.debug('Could not find source root for {source}.'
' Missing call to SourceRoot.register()? Fell back to {base}.'
.format(source=source, base=base))
if base not in sources_by_base:
sources_by_base[base] = OrderedSet()
sources_by_base[base].add(source)
return sources_by_base
def _jars_to_directories(self, target):
"""Extracts and maps jars to directories containing their contents.
:returns: a set of filepaths to directories containing the contents of jar.
"""
files = set()
jar_import_products = self.context.products.get_data(JarImportProducts)
imports = jar_import_products.imports(target)
for coordinate, jar in imports:
files.add(self._extract_jar(coordinate, jar))
return files
def _extract_jar(self, coordinate, jar_path):
"""Extracts the jar to a subfolder of workdir/extracted and returns the path to it."""
with open(jar_path, 'rb') as f:
outdir = os.path.join(self.workdir, 'extracted', sha1(f.read()).hexdigest())
if not os.path.exists(outdir):
ZIP.extract(jar_path, outdir)
self.context.log.debug('Extracting jar {jar} at {jar_path}.'
.format(jar=coordinate, jar_path=jar_path))
else:
self.context.log.debug('Jar {jar} already extracted at {jar_path}.'
.format(jar=coordinate, jar_path=jar_path))
return outdir
def _proto_path_imports(self, proto_targets):
for target in proto_targets:
for path in self._jars_to_directories(target):
yield os.path.relpath(path, get_buildroot())
def calculate_genfiles(self, path, source):
protobuf_parse = ProtobufParse(path, source)
protobuf_parse.parse()
return OrderedSet(self.calculate_java_genfiles(protobuf_parse))
def calculate_java_genfiles(self, protobuf_parse):
basepath = protobuf_parse.package.replace('.', os.path.sep)
classnames = {protobuf_parse.outer_class_name}
if protobuf_parse.multiple_files:
classnames |= protobuf_parse.enums | protobuf_parse.messages | protobuf_parse.services | \
set(['{name}OrBuilder'.format(name=m) for m in protobuf_parse.messages])
for classname in classnames:
yield os.path.join(basepath, '{0}.java'.format(classname))
class ProtobufGlobalCodegenStrategy(SimpleCodegenTask.GlobalCodegenStrategy):
def find_sources(self, target):
return self._task.sources_generated_by_target(target)
def _same_contents(a, b):
"""Perform a comparison of the two files"""
with open(a, 'rb') as fp_a, open(b, 'rb') as fp_b:
return fp_a.read() == fp_b.read()
def check_duplicate_conflicting_protos(task, sources_by_base, sources, log):
"""Checks if proto files are duplicate or conflicting.
There are sometimes two files with the same name on the .proto path. This causes the protobuf
compiler to stop with an error. Some repos have legitimate cases for this, and so this task
decides to just choose one to keep the entire build from failing. Sometimes, they are identical
copies. That is harmless, but if there are two files with the same name with different contents,
that is ambiguous and we want to complain loudly.
:param task: provides an implementation of the method calculate_genfiles()
:param dict sources_by_base: mapping of base to path
:param set|OrderedSet sources: set of sources
:param Context.Log log: writes error messages to the console for conflicts
"""
sources_by_genfile = {}
for base in sources_by_base.keys(): # Need to iterate over /original/ bases.
for path in sources_by_base[base]:
if not path in sources:
continue # Check to make sure we haven't already removed it.
source = path[len(base):]
genfiles = task.calculate_genfiles(path, source)
for genfile in genfiles:
if genfile in sources_by_genfile:
# Possible conflict!
prev = sources_by_genfile[genfile]
if not prev in sources:
# Must have been culled by an earlier pass.
continue
if not _same_contents(path, prev):
log.error('Proto conflict detected (.proto files are different):\n'
'1: {prev}\n2: {curr}'.format(prev=prev, curr=path))
else:
log.warn('Proto duplication detected (.proto files are identical):\n'
'1: {prev}\n2: {curr}'.format(prev=prev, curr=path))
log.warn(' Arbitrarily favoring proto 1.')
if path in sources:
sources.remove(path) # Favor the first version.
continue
sources_by_genfile[genfile] = path
| kslundberg/pants | src/python/pants/backend/codegen/tasks/protobuf_gen.py | Python | apache-2.0 | 13,284 | 0.008883 |
# vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright 2012 Michael Still and Canonical 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.
"""Config Drive v2 helper."""
import os
import shutil
import tempfile
from oslo.config import cfg
from nova import exception
from nova.openstack.common import fileutils
from nova.openstack.common.gettextutils import _
from nova.openstack.common import log as logging
from nova import utils
from nova import version
LOG = logging.getLogger(__name__)
configdrive_opts = [
cfg.StrOpt('config_drive_format',
default='iso9660',
help='Config drive format. One of iso9660 (default) or vfat'),
cfg.StrOpt('config_drive_tempdir',
default=tempfile.tempdir,
help=('Where to put temporary files associated with '
'config drive creation')),
# force_config_drive is a string option, to allow for future behaviors
# (e.g. use config_drive based on image properties)
cfg.StrOpt('force_config_drive',
help='Set to force injection to take place on a config drive '
'(if set, valid options are: always)'),
cfg.StrOpt('mkisofs_cmd',
default='genisoimage',
help='Name and optionally path of the tool used for '
'ISO image creation')
]
CONF = cfg.CONF
CONF.register_opts(configdrive_opts)
# Config drives are 64mb, if we can't size to the exact size of the data
CONFIGDRIVESIZE_BYTES = 64 * 1024 * 1024
class ConfigDriveBuilder(object):
"""Build config drives, optionally as a context manager."""
def __init__(self, instance_md=None):
self.imagefile = None
# TODO(mikal): I don't think I can use utils.tempdir here, because
# I need to have the directory last longer than the scope of this
# method call
self.tempdir = tempfile.mkdtemp(dir=CONF.config_drive_tempdir,
prefix='cd_gen_')
if instance_md is not None:
self.add_instance_metadata(instance_md)
def __enter__(self):
return self
def __exit__(self, exctype, excval, exctb):
if exctype is not None:
# NOTE(mikal): this means we're being cleaned up because an
# exception was thrown. All bets are off now, and we should not
# swallow the exception
return False
self.cleanup()
def _add_file(self, path, data):
filepath = os.path.join(self.tempdir, path)
dirname = os.path.dirname(filepath)
fileutils.ensure_tree(dirname)
with open(filepath, 'w') as f:
f.write(data)
def add_instance_metadata(self, instance_md):
for (path, value) in instance_md.metadata_for_config_drive():
self._add_file(path, value)
LOG.debug(_('Added %(filepath)s to config drive'),
{'filepath': path})
def _make_iso9660(self, path):
publisher = "%(product)s %(version)s" % {
'product': version.product_string(),
'version': version.version_string_with_package()
}
utils.execute(CONF.mkisofs_cmd,
'-o', path,
'-ldots',
'-allow-lowercase',
'-allow-multidot',
'-l',
'-publisher',
publisher,
'-quiet',
'-J',
'-r',
'-V', 'config-2',
self.tempdir,
attempts=1,
run_as_root=False)
def _make_vfat(self, path):
# NOTE(mikal): This is a little horrible, but I couldn't find an
# equivalent to genisoimage for vfat filesystems.
with open(path, 'w') as f:
f.truncate(CONFIGDRIVESIZE_BYTES)
utils.mkfs('vfat', path, label='config-2')
mounted = False
try:
mountdir = tempfile.mkdtemp(dir=CONF.config_drive_tempdir,
prefix='cd_mnt_')
_out, err = utils.trycmd('mount', '-o',
'loop,uid=%d,gid=%d' % (os.getuid(),
os.getgid()),
path, mountdir,
run_as_root=True)
if err:
raise exception.ConfigDriveMountFailed(operation='mount',
error=err)
mounted = True
# NOTE(mikal): I can't just use shutils.copytree here, because the
# destination directory already exists. This is annoying.
for ent in os.listdir(self.tempdir):
shutil.copytree(os.path.join(self.tempdir, ent),
os.path.join(mountdir, ent))
finally:
if mounted:
utils.execute('umount', mountdir, run_as_root=True)
shutil.rmtree(mountdir)
def make_drive(self, path):
"""Make the config drive.
:param path: the path to place the config drive image at
:raises ProcessExecuteError if a helper process has failed.
"""
if CONF.config_drive_format == 'iso9660':
self._make_iso9660(path)
elif CONF.config_drive_format == 'vfat':
self._make_vfat(path)
else:
raise exception.ConfigDriveUnknownFormat(
format=CONF.config_drive_format)
def cleanup(self):
if self.imagefile:
fileutils.delete_if_exists(self.imagefile)
try:
shutil.rmtree(self.tempdir)
except OSError as e:
LOG.error(_('Could not remove tmpdir: %s'), str(e))
def required_by(instance):
return instance.get('config_drive') or CONF.force_config_drive
| ntt-sic/nova | nova/virt/configdrive.py | Python | apache-2.0 | 6,518 | 0 |
# 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 ConnStringInfo(Model):
"""Database connection string information.
:param name: Name of connection string.
:type name: str
:param connection_string: Connection string value.
:type connection_string: str
:param type: Type of database. Possible values include: 'MySql',
'SQLServer', 'SQLAzure', 'Custom', 'NotificationHub', 'ServiceBus',
'EventHub', 'ApiHub', 'DocDb', 'RedisCache'
:type type: str or :class:`ConnectionStringType
<azure.mgmt.web.models.ConnectionStringType>`
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'connection_string': {'key': 'connectionString', 'type': 'str'},
'type': {'key': 'type', 'type': 'ConnectionStringType'},
}
def __init__(self, name=None, connection_string=None, type=None):
self.name = name
self.connection_string = connection_string
self.type = type
| rjschwei/azure-sdk-for-python | azure-mgmt-web/azure/mgmt/web/models/conn_string_info.py | Python | mit | 1,434 | 0 |
'''
Created on Feb. 23, 2019
Utility functions to extract data from xarray Dataset or DataArray classes.
@author: Andre R. Erler, GPL v3
'''
from warnings import warn
from datetime import datetime
import os
import numpy as np
import xarray as xr
import netCDF4 as nc
from dask.diagnostics import ProgressBar
# internal imports
from geospatial.netcdf_tools import getNCAtts, geospatial_netcdf_version, zlib_default # this import should be fine
## an important option I am relying on!
xr.set_options(keep_attrs=True)
# names of valid geographic/projected coordinates
default_x_coords = dict(geo=('lon','long','longitude',), proj=('x','easting','west_east') )
default_y_coords = dict(geo=('lat','latitude',), proj=('y','northing','south_north'))
default_lon_coords = default_x_coords['geo']; default_lat_coords = default_y_coords['geo']
## helper functions
def getAtts(xvar, lraise=True):
''' return dictionary of attributed from netCDF4 or xarray '''
if isinstance(xvar,(xr.DataArray,xr.Variable,xr.Dataset)):
atts = xvar.attrs.copy()
elif isinstance(xvar,(nc.Variable,nc.Dataset)):
atts = getNCAtts(xvar)
elif lraise:
raise TypeError(xvar)
return atts
## functions to interface with rasterio
def getGeoDims(xvar, x_coords=None, y_coords=None, lraise=True):
''' helper function to identify geographic/projected dimensions by name '''
if x_coords is None: x_coords = default_x_coords
if y_coords is None: y_coords = default_y_coords
xlon,ylat = None,None # return None, if nothing is found
if isinstance(xvar,(xr.DataArray,xr.Dataset)):
# test geographic grid and projected grids separately
for coord_type in x_coords.keys():
for name in xvar.dims.keys() if isinstance(xvar,xr.Dataset) else xvar.dims:
if name.lower() in x_coords[coord_type]:
xlon = name; break
for name in xvar.dims.keys() if isinstance(xvar,xr.Dataset) else xvar.dims:
if name.lower() in y_coords[coord_type]:
ylat = name; break
if xlon is not None and ylat is not None: break
else: xlon,ylat = None,None
elif isinstance(xvar,(nc.Dataset,nc.Variable)):
# test geographic grid and projected grids separately
for coord_type in x_coords.keys():
for name in xvar.dimensions:
if name.lower() in x_coords[coord_type]:
xlon = name; break
for name in xvar.dimensions:
if name.lower() in y_coords[coord_type]:
ylat = name; break
if xlon is not None and ylat is not None: break
else: xlon,ylat = None,None
elif lraise: # optionally check input
raise TypeError("Can only infer coordinates from xarray or netCDF4 - not from {}".format(xvar.__class__))
else:
pass # return None,None
return xlon,ylat
def getGeoCoords(xvar, x_coords=None, y_coords=None, lraise=True, lvars=True):
''' helper function to extract geographic/projected coordinates from xarray'''
# find dim names
xlon_dim,ylat_dim = getGeoDims(xvar, x_coords=x_coords, y_coords=y_coords, lraise=lraise)
# find coordinates
if isinstance(xvar,(xr.DataArray,xr.Dataset)):
if xlon_dim in xvar.coords:
xlon = xvar.coords[xlon_dim] if lvars else xlon_dim
else: xlon = None
if ylat_dim in xvar.coords:
ylat = xvar.coords[ylat_dim] if lvars else ylat_dim
else: ylat = None
elif isinstance(xvar,nc.Variable) and lraise:
raise TypeError("Cannot infer coordinates from netCDF4 Variable - only Dataset!")
elif isinstance(xvar,nc.Dataset):
if xlon_dim in xvar.variables:
xlon = xvar.variables[xlon_dim] if lvars else xlon_dim
else: xlon = None
if ylat_dim in xvar.variables:
ylat = xvar.variables[ylat_dim] if lvars else ylat_dim
else: ylat = None
# optionally raise error if no coordinates are found, otherwise just return None
if lraise and (xlon is None or ylat is None):
raise ValueError("No valid pair of geographic coodinates found:\n {}".format(xvar.dims))
# return a valid pair of geographic or projected coordinate axis
return xlon,ylat
def isGeoVar(xvar, x_coords=None, y_coords=None, lraise=True):
''' helper function to identify variables that have geospatial coordinates (geographic or
projected), based on xarray or netCDF4 dimension names '''
if x_coords is None: x_coords = default_x_coords
if y_coords is None: y_coords = default_y_coords
if isinstance(xvar,(xr.DataArray,xr.Dataset)):
dims = xvar.coords.keys()
elif isinstance(xvar,(nc.Dataset,nc.Variable)):
dims = xvar.dimensions
elif lraise:
raise TypeError("Can only infer coordinate system from xarray or netCDF4 - not from {}".format(xvar.__class__))
else:
return None # evaluates as False, but allows checking
# test geographic grid and projected grids separately
for coord_type in x_coords.keys():
xlon,ylat = False,False
for name in dims:
if name.lower() in x_coords[coord_type]:
xlon = True; break
for name in dims:
if name.lower() in y_coords[coord_type]:
ylat = True; break
if xlon and ylat: break
# if it has a valid pair of geographic or projected coordinate axis
return ( xlon and ylat )
def isGeoCRS(xvar, lat_coords=None, lon_coords=None, lraise=True):
''' helper function to determine if we have a simple geographic lat/lon CRS (based on xarray dimension names) '''
lat,lon = False,False
if lon_coords is None: lon_coords = default_x_coords['geo']
if lat_coords is None: lat_coords = default_y_coords['geo']
if isinstance(xvar,(xr.DataArray,xr.Dataset)):
dims = xvar.coords.keys()
elif isinstance(xvar,(nc.Dataset,nc.Variable)):
dims = xvar.dimensions
elif lraise:
raise TypeError("Can only infer coordinate system from xarray or netCDF4- not from {}".format(xvar.__class__))
else:
return None # evaluates as False, but allows checking
# check dimension names
for name in dims:
if name.lower() in lon_coords:
lon = True; break
for name in dims:
if name.lower() in lat_coords:
lat = True; break
# it is a geographic coordinate system if both, lat & lon are present
return ( lat and lon )
def getTransform(xvar=None, x=None, y=None, lcheck=True):
''' generate an affine transformation from xarray coordinate axes '''
from rasterio.transform import Affine # to generate Affine transform
if isinstance(xvar,(xr.DataArray,xr.Dataset,nc.Dataset)):
x,y = getGeoCoords(xvar, lraise=True)
elif xvar is None and isinstance(x,(xr.DataArray,nc.Variable)) and isinstance(y,(xr.DataArray,nc.Variable)):
pass # x and y axes are supplied directly
elif xvar:
raise TypeError('Can only infer GeoTransform from xarray Dataset or DataArray or netCDF4 Dataset\n - not from {}.'.format(xvar))
# check X-axis
if isinstance(x,xr.DataArray): x = x.data
elif isinstance(x,nc.Variable): x = x[:]
if not isinstance(x,np.ndarray):
raise TypeError(x)
diff_x = np.diff(x); dx = diff_x.min()
if lcheck and not np.isclose(dx, diff_x.max(), rtol=1.e-2):
raise ValueError("X-axis is not regular: {} - {}".format(dx, diff_x.max()))
# check Y-axis
if isinstance(y,xr.DataArray): y = y.data
elif isinstance(y,nc.Variable): y = y[:]
if not isinstance(y,np.ndarray):
raise TypeError(y)
diff_y = np.diff(y); dy = diff_y.min()
if lcheck and not np.isclose(dy, diff_y.max(), rtol=1.e-2):
raise ValueError("Y-axis is not regular. {} - {}".format(dy, diff_y.max()))
# generate transform
return Affine.from_gdal(x[0]-dx/2.,dx,0.,y[0]-dy/2.,0.,dy), (len(x),len(y))
def readCFCRS(xds, grid_mapping=None, lraise=True, lproj4=False):
''' function to generate CRS from CF-Convention grid mapping variable; only works with Datasets '''
# read CF convention string
if not isinstance(xds,(nc.Dataset,xr.Dataset)):
raise TypeError("Only xarray of netCDF4 Datasets are supported.")
atts = getAtts(xds) # works for xarray or netCDF4
if 'Conventions' in atts:
cf_str = atts['Conventions']
if cf_str[:3] != 'CF-' or float(cf_str[3:]) < 1:
raise ValueError("Only CF convection version 1 or later is supported; not '{}'.".format(cf_str))
elif lraise:
raise ValueError("No CF convention attribute found; this Dataset may not adhere to CF conventions.")
else:
return None # return without CRS
# find grid mapping variable
if grid_mapping:
if grid_mapping in xds.variables:
grid_type = grid_mapping
grid_atts = getAtts(xds.variables[grid_mapping])
else:
raise ValueError("Grid mapping '{}' not found in dataset.".format(grid_mapping))
else:
grid_type = None
grid_varlist = ['Lambert_Conformal']
for grid_var in grid_varlist:
if grid_var in xds.variables:
if grid_type is None:
grid_type = grid_var
grid_atts = getAtts(xds.variables[grid_var])
else:
raise ValueError("Multiple grid_mapping variables detected:",grid_type,grid_var)
if grid_type is None:
if lraise:
raise NotImplementedError("No supported grid_mapping variable detected:\n",grid_varlist)
else:
return None # return without CRS
elif grid_type == 'Lambert_Conformal':
assert grid_atts['grid_mapping_name'] == "lambert_conformal_conic", grid_atts
proj4 = ('+proj=lcc +lat_1={lat_1} +lat_2={lat_1} '.format(lat_1=grid_atts['standard_parallel'])
+ '+lat_0={lat_0} +lon_0={lon_0} '.format(lat_0=grid_atts['latitude_of_projection_origin'],
lon_0=grid_atts['longitude_of_central_meridian'])
+ '+x_0=0 +y_0=0 +a=6371229 +b=6371229 +units=m +no_defs' )
else:
raise NotImplementedError("The grid_mapping '{}' is currently not implemented/supported.".format(grid_type))
import rasterio as rio
# return either string or CRS object
if lproj4: crs = proj4
else: crs = rio.crs.CRS.from_string(proj4) # initialize from Proj4 string
return crs
def getCRS(xvar, lraise=True):
''' infer projection from a xarray Dataset or DataArray; this function assumes that either a proj4 string or
an EPSG designation is stored in the attributes of the dataset/variable. '''
from geospatial.rasterio_tools import genCRS # used to generate CRS object
if isinstance(xvar,(xr.DataArray,xr.Dataset)):
atts = xvar.attrs
elif isinstance(xvar,(nc.Variable,nc.Dataset)):
atts = getAtts(xvar)
elif lraise:
raise TypeError("Can only infer coordinate system from xarray or netCDF4 - not from {}".format(xvar.__class__))
else:
return None # no projection
crs = None
# check CF convention
if isinstance(xvar,(xr.Dataset,nc.Dataset)):
crs = readCFCRS(xvar, lraise=False, lproj4=False)
# search for EPSG number
if crs is None:
for key,value in atts.items():
if key.upper() == 'EPSG' and value != 'n/a': crs = genCRS(value); break
# search for Proj4 string
if crs is None:
for key,value in atts.items():
if key.lower() == 'proj4' and value != 'n/a': crs = genCRS(value); break
# check for simple geographic lat/lon system
if crs is None:
if isGeoCRS(xvar, lraise=False): # error will be raised below (if desired)
crs = genCRS() # no arguments for default lat/lon
# return values
if lraise and crs is None:
raise ValueError("No projection information found in attributes.")
# return a GDAL/rasterio CRS instance
return crs
def inferGeoInfo(xvar, varname=None, crs=None, transform=None, size=None, lraise=True, lcheck=True):
''' infere geo-reference information from xarray DataArray or Dataset and netCDF4 Dataset '''
# CRS
_crs = getCRS(xvar, lraise=lraise)
if crs is None: crs = _crs
elif crs != _crs:
from geospatial.rasterio_tools import genCRS # used to generate CRS object
crs = genCRS(crs)
if crs != _crs:
raise ValueError("Prescribed CRS and inferred CRS are incompatible:\n{}\n{}".format(crs,_crs))
crs = _crs # for some reason EPSG ints also pass the equality test...
# geotransform & grid size
xlon,ylat = getGeoCoords(xvar, lraise=True, lvars=False)
_transform, _size = getTransform(xvar, lcheck=lraise)
if transform is None: transform = _transform
elif not transform is _transform:
raise ValueError("Prescribed and inferred Geotransform are incompatible:\n{}\n{}".format(transform,_transform))
if size is None: size = _size
elif not size is _size:
raise ValueError("Prescribed and inferred grid sizes are incompatible:\n{}\n{}".format(size,_size))
# do some checks
if lcheck:
if crs.is_projected and isGeoCRS(xvar):
raise ValueError(crs,xvar) # simple check
if isinstance(xvar,xr.Dataset) and varname:
xvar = xvar[varname]
shape = None; dims = None
if isinstance(xvar,xr.DataArray):
shape = xvar.data.shape; dims = xvar.dims
if xvar.attrs.get('dim_order',None) is False:
raise NotImplementedError("The x/lon and y/lat axes of this xarray have to be swapped:\n {}".format(xvar))
elif isinstance(xvar,nc.Dataset) and varname:
xvar = xvar.variables[varname]
shape = xvar.shape; dims = xvar.dimensions
if shape:
if shape[-2:] != (size[1],size[0]):
raise ValueError(xvar)
if dims:
if dims[-2] != ylat or dims[-1] != xlon:
raise ValueError(xvar)
# return verified georef info
return crs, transform, size
## functions that modify a dataset
def _inferVarmap(varmap=None, varatts=None, linvert=False):
''' simple function that infers a varmap using varatts, if necessary '''
if varmap is None:
varmap = dict()
if varatts is not None:
for varname,atts in varatts.items():
if 'name' in atts: varmap[varname] = atts['name']
elif not isinstance(varmap,dict):
raise TypeError(varmap)
if linvert:
varmap = {value:key for key,value in varmap.items()}
# return varmap (guaranteed to be a dict)
return varmap
def updateVariableAttrs(xds, varatts=None, varmap=None, varlist=None, **kwargs):
''' a helper function to update variable attributes, rename variables, and apply scaling factors '''
# update varatts
if varatts is None:
varatts = dict()
elif isinstance(varatts,dict):
varatts = varatts.copy()
else:
raise TypeError(varatts)
varatts.update(kwargs) # add kwargs
# generate varmap
varmap = _inferVarmap(varmap=varmap, varatts=varatts, linvert=False)
# drop variables
if varlist is not None:
drop_list = []
for varname in xds.data_vars.keys():
name = varmap.get(varname,varname)
if name not in varlist: drop_list.append(varname)
xds = xds.drop_vars(drop_list)
# update attributes (using old names)
date_str = datetime.today().strftime('%Y%m%d')
for varname,atts in varatts.items():
if varname in xds.variables:
if varname == 'time':
warn("The 'time' coordinate is handled automatically by xarray using numpy datetime64; "
+ "changing attributes can break this functionality when the dataset is saved to file. ")
var = xds.variables[varname]
attrs = var.attrs.copy()
if 'updated' not in attrs:
if 'units' in atts:
if 'units' not in attrs or attrs['units'] != atts['units']:
if 'scalefactor' in atts and atts['scalefactor'] != 1:
var *= atts['scalefactor'] # this should execute lazily...
if 'offset' in atts and atts['offset'] != 0:
var += atts['offset'] # this should execute lazily...
# transfer attributes
for key,value in atts.items():
if key not in ('scalefactor','offset'):
if key in attrs: attrs['old_'+key] = attrs[key]
attrs[key] = value
attrs['updated'] = date_str # indicate we have updated with date string
var.attrs = attrs
# actually rename (but only vars that are present and need to be renamed...)
xds = xds.rename({key:val for key,val in varmap.items() if key in xds.variables and key != val})
xds = xds.rename_dims({key:val for key,val in varmap.items() if key in xds.dims and key != val})
xds.attrs['updated'] = date_str
return xds
def addGeoReference(xds, proj4_string=None, x_coords=None, y_coords=None, lcreate=False, xlon_coord=None, ylat_coord=None):
''' helper function to add GDAL/rasterio-style georeferencing information to an xarray dataset;
note that this only refers to attributed, not axes, but also includes variables '''
xlon,ylat = getGeoCoords(xds, x_coords=x_coords, y_coords=y_coords, lvars=lcreate, lraise=not lcreate)
if lcreate:
if (xlon is None and ylat is None):
assert xlon_coord is not None and ylat_coord is not None
# need to find names again...
xlon_dim,ylat_dim = getGeoDims(xds, x_coords=x_coords, y_coords=y_coords, lraise=True)
# create new xlon/ylat coordinates, based on coordinates passed down
coords = {xlon_dim:xlon_coord, ylat_dim:ylat_coord}
xds = xds.assign_coords(**coords)
elif (xlon is not None) and (ylat is not None):
xlon = xlon.name; ylat = ylat.name # from here on only need names
else:
raise ValueError("No valid pair of geographic coodinates found:\n {}".format(xds.dims))
xds.attrs['xlon'] = xlon
xds.attrs['ylat'] = ylat
if proj4_string is None:
if isGeoVar(xds, x_coords, y_coords, lraise=True):
proj4_string = '+proj=longlat +lon_0=0 +lat_0=0 +ellps=WGS84 +datum=WGS84' # default geographic, also EPSG 4326
else:
raise ValueError("Cannot infer projection - need to provide proj4 string!")
elif isinstance(proj4_string,str):
xds.attrs['proj4'] = proj4_string
else:
raise TypeError("Cannot infer projection - need to provide proj4 string!")
for xvar in list(xds.data_vars.values()):
if isGeoVar(xvar):
xvar.attrs['proj4'] = proj4_string
xvar.attrs['xlon'] = xlon
xvar.attrs['ylat'] = ylat
xvar.attrs['dim_order'] = int( xvar.dims[-2:] == (ylat, xlon) )
# N.B.: the NetCDF-4 backend does not like Python bools
return xds
def rechunkTo2Dslices(xvar, **other_chunks):
''' convenience function to rechunk an xarray so that the horizontal dimensions are contiguous (not chunked)
N.B.: rechunking in a way that does not simply combine existing chunks seems to cause all chunks/data
to be loaded into memory (we want to avoid that); also, chunks are defined by their size, not by
their number, i.e. the definition for one large 2D chunk is (len(y),len(x)) and *not* (1,1) '''
if not isinstance(xvar,(xr.DataArray,xr.Dataset)):
raise TypeError(xvar)
# old chunk sizes
if 'chunksizes' in xvar.encoding:
chunks = {dim:cs for dim,cs in zip(xvar.sizes,xvar.encoding['chunksizes'])}
else: chunks = dict()
chunks.update(other_chunks)
# find horizontal/map dimensions
xlon = xvar.attrs['xlon']; ylat = xvar.attrs['ylat']
chunks[xlon] = xvar.sizes[xlon]; chunks[ylat] = xvar.sizes[ylat]
return xvar.chunk(chunks=chunks) # rechunk x/lon and y/lat
def autoChunkXArray(xds, chunks=None, dims=None, **kwargs):
''' apply auto-chunking to an xarray object, like a Dataset or DataArray (chunks kw arg can override) '''
from geospatial.netcdf_tools import autoChunk
if dims is None:
xlon,ylat = getGeoCoords(xds)
dims = ('time', ylat.name, xlon.name)
dims = [dim for dim in dims if dim in xds.sizes]
shape = [xds.sizes[dim] for dim in dims]
cks = autoChunk(shape, **kwargs)
cks = {dim:c for dim,c in zip(dims,cks)}
if chunks: cks.update(chunks) # manually/explicitly specified chunks override
return xds.chunk(chunks=cks)
def getCommonChunks(xds, method='min'):
''' get smallest/largest/mean common denominator for chunks in dataset '''
chunk_list = dict()
# collect chunks
if isinstance(xds,xr.Dataset):
for xvar in xds.data_vars.values():
if 'chunksizes' in xvar.encoding:
for dim,cks in zip(xvar.dims,xvar.encoding['chunksizes']):
if dim in chunk_list: chunk_list[dim].append(cks)
else: chunk_list[dim] = [cks]
elif isinstance(xds,nc.Dataset):
for ncvar in xds.variables.values():
if ncvar.chunking():
for dim,cks in zip(ncvar.dimensions,ncvar.chunking()):
if dim in chunk_list: chunk_list[dim].append(cks)
else: chunk_list[dim] = [cks]
else:
raise TypeError(xds)
# reduce chunks
chunks = dict()
for dim,cks in list(chunk_list.items()):
chunks[dim] = getattr(np,method)(cks)
# return dict with chunksize for each dimension
return chunks
def computeNormals(xds, aggregation='month', time_stamp='time_stamp', lresample=False, time_name='time'):
''' function invoking lazy groupby() call and replacing the resulting time axis with a new time axis '''
lts = time_stamp and time_stamp in xds
# time stamp variable for meta data
if lts:
import pandas as pd
ts_var = xds[time_stamp].load()
period = (pd.to_datetime(ts_var.data[0]).year, (pd.to_datetime(ts_var.data[-1])+pd.Timedelta(31, unit='D')).year)
prdstr = '{:04d}-{:04d}'.format(*period)
# resample data to aggregation interval
if lresample:
if aggregation.lower() == 'month': rsi = 'MS'
else:
raise NotImplementedError(aggregation)
xds = xds.resample(time=rsi,skipna=True,).mean()
# N.B.: I am not sure to which extent resampling is necessary
# compute monthly normals
cds = xds.groupby('time.'+aggregation).mean('time')
assert len(cds['month']) == 12, cds
# convert time axis
cds = cds.rename({aggregation:time_name}) # the new time axis is named 'month'
tm = cds.coords[time_name]
tm.attrs['name'] = time_name
tm.attrs['long_name'] = 'Calendar '+aggregation.title()
tm.attrs['units'] = aggregation
# add period info for quick identification
if lts:
tm.attrs['start_date'] = str(ts_var.data[0])
tm.attrs['end_date'] = str(ts_var.data[-1])
tm.attrs['period'] = prdstr
# add attributes to dataset
cds.attrs['start_date'] = str(ts_var.data[0])
cds.attrs['end_date'] = str(ts_var.data[-1])
cds.attrs['period'] = prdstr
# return formatted climatology dataset
return cds
## function to load a dataset
def _multichunkPresets(multi_chunks):
''' translate string identifiers into valid multichunk dicts, based on presets '''
if isinstance(multi_chunks,str):
if multi_chunks.lower() == 'regular': # 256 MB
multi_chunks = {dim:16 for dim in ('lat','lon','latitude','longitude','x','y',)}
multi_chunks['time'] = 8
elif multi_chunks.lower() == 'small': # 64 MB
multi_chunks = {dim:8 for dim in ('lat','lon','latitude','longitude','x','y','time')}
elif multi_chunks.lower() == 'time': # 184 MB
multi_chunks = {dim:4 for dim in ('lat','lon','latitude','longitude','x','y')}
multi_chunks['time'] = 92 # for reductions along time, we can use a higher value (8 days * 92 ~ 2 years)
else:
raise NotImplementedError(multi_chunks)
elif ( multi_chunks is not None ) and not isinstance(multi_chunks, dict):
raise TypeError(multi_chunks)
# return valid multi_chunks (dict)
return multi_chunks
def loadXArray(varname=None, varlist=None, folder=None, varatts=None, filename_pattern=None, filelist=None, default_varlist=None,
varmap=None, mask_and_scale=True, grid=None, lgeoref=True, geoargs=None, chunks=True, multi_chunks=None,
ldropAtts=False, lskip=False, filetypes=None,
compat='override', join='inner', fill_value=np.NaN, combine_attrs='no_conflicts', **kwargs):
''' function to open a dataset in one of two modes: 1) variables are stored in separate files, but in the same folder (this mainly
applies to high-resolution, high-frequency (daily) observations, e.g. SnoDAS) or 2) multiple variables are stored in different
filetypes and each is opened and then merged (usually model output); datasets are opened using xarray '''
# load variables
if filetypes is None:
lopt1 = True
# option 1: one variable per file
if varname and varlist:
raise ValueError(varname,varlist)
elif varname:
varlist = [varname] # load a single variable
elif varlist is None:
varlist = default_varlist
# add variable filetypes
# if there is a (implied) varmap, we need to apply that to variable-filetypes
ravmap = _inferVarmap(varmap=varmap, varatts=varatts, linvert=True)
filetypes = [ravmap.get(varname,varname) for varname in varlist]
# now also transform varatts and varmap
varmap_single = None if varmap is None else varmap.copy()
varatts_single = None if varatts is None else varatts.copy()
varatts = {filetype:varatts_single for filetype in filetypes}
varmap = {filetype:varmap_single for filetype in filetypes}
else:
lopt1 = False # just to remember when using option 2
## now use option 2: multiple variables per file
# expand varmap to filetypes
if varmap is None:
varmap = {filetype:None for filetype in filetypes} # no varmap
elif isinstance(varmap,dict):
filetypes_set = set(filetypes); varmap_set = set(varmap.keys())
if varmap_set.issubset(filetypes_set) or filetypes_set.issubset(varmap_set): # expand to filetypes using None
for filetype in filetypes:
if filetype in varmap_set:
if not isinstance(varmap[filetype],dict) and varmap[filetype] is not None:
raise TypeError(filetype,varmap[filetype])
else:
varmap[filetype] = None
elif any([key in filetypes for key in varmap.keys()]):
raise ValueError("It is unclear if varmap is a dict containing varmap dicts for each filetype or just one varmap dict.",varmap.keys())
if all([key in filetypes for key in varmap.keys()]): # one varmap per filetype
if not all([isinstance(value,dict) or value is None for value in varmap.values()]):
raise TypeError(varmap)
elif any([key in filetypes for key in varmap.keys()]):
raise ValueError(varmap.keys())
else:
varmap = {filetype:varmap for filetype in filetypes} # same varmap for all
else:
raise TypeError(varmap)
# expand varatts to filetypes
if varatts is None:
varatts = {filetype:None for filetype in filetypes} # no varatts
elif isinstance(varatts,dict):
filetypes_set = set(filetypes); varatts_set = set(varatts.keys())
if varatts_set.issubset(filetypes_set) or filetypes_set.issubset(varatts_set): # expand to filetypes using None
for filetype in filetypes:
if filetype in varatts_set:
if not isinstance(varatts[filetype],dict) and varatts[filetype] is not None:
raise TypeError(filetype,varatts[filetype])
else:
varatts[filetype] = None
elif any([key in filetypes for key in varatts.keys()]):
raise ValueError("It is unclear if varatts is a dict containing varatts dicts for each filetype or just one varatts dict.",varatts.keys())
else:
varatts = {filetype:varatts for filetype in filetypes} # same varatts for all
else:
raise TypeError(varatts)
# expand filename/pattern to filetypes
if filename_pattern and not filelist:
filelist = filename_pattern
if isinstance(filelist, dict):
if len(filelist) != len(filetypes):
raise ValueError(filelist)
elif isinstance(filelist, str):
filelist = {filetype:filelist for filetype in filetypes}
else:
raise ValueError(filelist)
# just some default settings that will produce chunks larger than 100 MB on 8*64*64 float chunks
multi_chunks = _multichunkPresets(multi_chunks)
orig_chunks = chunks.copy() if isinstance(chunks, dict) else chunks # deep copy or True or None
# construct dataset
ds_list = []
for filetype in filetypes:
filename = filelist[filetype].lower().format(var=filetype.lower(), type=filetype.lower()) # all lower case
filepath = '{}/{}'.format(folder,filename)
chunks = orig_chunks # reset
# apply varmap in reverse to varlist
if os.path.exists(filepath):
# load dataset
if chunks is True:
# infer chunks from NetCDF-4 file (not sure why xarray doesn't do this automatically...)
with nc.Dataset(filepath, 'r') as ncds : # open in read-only using NetCDF4 module
chunks = dict()
for varname,ncvar in ncds.variables.items():
for dim,size in zip(ncvar.dimensions,ncvar.chunking()):
chunks[dim] = size # this just selects the last value... not necessarily always the same
if dim in chunks and chunks[dim] != size:
print("WARNING: Chunks for dimension '{}' not coherent in file:\n '{}'".format(dim, filepath))
if multi_chunks: # enlarge chunks with multiplier
chunks = {dim:(val*multi_chunks.get(dim,1)) for dim,val in chunks.items()}
# open dataset with xarray
#print(varname,chunks)
ds = xr.open_dataset(filepath, chunks=chunks, mask_and_scale=mask_and_scale, **kwargs)
# N.B.: the use of open_mfdataset is problematic, because it does not play nicely with chunking -
# by default it loads everything as one chunk, and it only respects chunking, if chunks are
# specified explicitly at the initial load time (later chunking seems to have no effect!)
# That being said, I don't know if this is still the case...
# rename, prune/drop vars and apply attributes
if ldropAtts: ds.attrs = dict() # drop original attributes from NC file (still add georef etc.)
if varatts or varmap:
ds = updateVariableAttrs(ds, varatts=varatts[filetype], varmap=varmap[filetype],
varlist=None if lopt1 else varlist)
ds_list.append(ds)
else:
if lskip:
print("Skipping missing dataset file '{}' ('{}')".format(filename,folder))
else:
raise IOError("The dataset file '{}' was not found in folder:\n '{}'".format(filename,folder))
# merge into new dataset
if len(ds_list) == 0:
raise ValueError("Dataset is empty - aborting! Folder: \n '{}'".format(folder))
# resolve a very common conflict caused by NCO logging
if np.sum(['history' in ds.attrs for ds in ds_list]) > 1:
for ds in ds_list:
if 'history' in ds.attrs: ds.attrs['history'] = 'conflicting sources'
xds = xr.merge(ds_list, compat=compat, join=join, fill_value=fill_value, combine_attrs=combine_attrs)
# add projection info
if lgeoref:
if geoargs is not None:
# check
if 'proj4' in xds.attrs and 'proj4_string' in geoargs:
if xds.attrs['proj4'] != geoargs['proj4_string']:
raise ValueError(xds.attrs['proj4'])
# custom options
xds = addGeoReference(xds, **geoargs)
# default options
elif 'proj4' in xds.attrs:
# read projection string
xds = addGeoReference(xds, proj4_string=xds.attrs['proj4'])
elif grid:
# load griddef from pickle
from geodata.gdal import loadPickledGridDef
griddef = loadPickledGridDef(grid=grid)
xds = addGeoReference(xds, proj4_string=griddef.projection.ExportToProj4(),)
else:
# use default lat/lon, if it works...
xds = addGeoReference(xds,)
return xds
def saveXArray(xds, filename=None, folder=None, mode='overwrite', varlist=None, chunks=None, encoding=None, laddTime=None,
time_dim='time', time_agg=None, ltmpfile=True, lcompute=True, lprogress=True, lfeedback=True, **kwargs):
''' function to save a xarray dataset to disk, with options to add/overwrite variables, choose smart encoding,
add timstamps, use a temp file, and handle dask functionality '''
from geospatial.netcdf_tools import addTimeStamps, addNameLengthMonth
# file path and tmp file
if folder:
filepath = '{}/{}'.format(folder,filename)
# if file exists, get varlist and chunks
if not os.path.exists(filepath) or mode.lower() in ('overwrite','write'):
# create a new file
nc_mode = 'w'
if lfeedback: print("\nExporting to new NetCDF-4 file:")
else:
# if file exists and we are appending...
nc_mode = 'a' # in most cases
ltmpfile = not lcompute # only works with new file (or dummy...)
if mode.lower() in ('add_new',):
if lfeedback: print("\nAppending to existing NetCDF-4 file (only adding new variables):")
elif mode.lower() in ('add_all',):
if lfeedback: print("\nAppending to existing NetCDF-4 file (overwriting existing variables):")
else:
raise ValueError(mode)
# determine tmp file
if ltmpfile:
tmp_filepath = filepath + ( '.tmp' if lcompute else '.test' ) # use temporary file during creation
else:
tmp_filepath = filepath
if lfeedback: print(" '{}'".format(tmp_filepath))
## handle varlist and existing variables in file
# user-supplied varlist
if varlist:
drop_vars = [xvar for xvar in xds.data_vars.keys() if xvar not in varlist]
xds = xds.drop_vars(drop_vars) # returns a shallow copy with vars removed
# handle existing
if nc_mode == 'a':
# open existing file and get encoding
with nc.Dataset(filepath, 'r') as ncds:
if chunks is None: chunks = getCommonChunks(ncds)
if mode.lower() == 'add_new':
nc_varlist = [var for var in ncds.variables.keys() if var not in ncds.dimensions]
drop_vars = [xvar for xvar in xds.data_vars.keys() if xvar in nc_varlist]
xds = xds.drop_vars(drop_vars) # returns a shallow copy with vars removed
# adding all variables and overwriting existing ones, requires no changes except nc_mode = 'a'
# setup encoding
if encoding is None:
encoding = dict(); default = None
else:
default = encoding.pop('DEFAULT',None)
for varname,xvar in xds.data_vars.items():
tmp = zlib_default.copy()
cks = tuple(1 if dim == 'time' else chunks[dim] for dim in xvar.dims)
tmp['chunksizes'] = cks # depends on variable
# N.B.: use chunk size 1 for time and as before for space; monthly chunks make sense, since
# otherwise normals will be expensive to compute (access patterns are not sequential)
if isinstance(xvar.dtype,np.inexact): encoding[varname]['_FillValue'] = np.NaN
if default: tmp.update(default)
if varname not in encoding:
encoding[varname] = tmp
else:
tmp.update(encoding[varname])
encoding[varname] = tmp
#print(varname,cks,rvar.encoding)
# write to NetCDF
## write to file (with progress)
# write results to file (actually just create file)
task = xds.to_netcdf(tmp_filepath, mode=nc_mode, format='NETCDF4', unlimited_dims=['time'],
engine='netcdf4', encoding=encoding, compute=False)
if lcompute:
# execute with or without progress bar
if lprogress:
with ProgressBar():
task.compute()
else:
task.compute()
## add extras
with nc.Dataset(tmp_filepath, mode='a') as ncds:
if laddTime:
time_coord = ncds.variables[time_dim]
tatts = getNCAtts(time_coord)
tname = tatts.get('long_name','')
if tname.lower().startswith('calendar '):
# info on month for climatology
from geospatial.netcdf_tools import default_mon_name_atts
if default_mon_name_atts['name'] in ncds.variables:
if lfeedback: print("\nName of months variable alrady exists.")
else:
if lfeedback: print("\nAdding name and length of months.")
assert tatts.get('units','').lower().startswith('month'), tatts # this assumes monthly time aggregation
assert not time_agg or time_agg.lower().startswith('month')
addNameLengthMonth(ncds, time_dim=time_dim)
else:
# time stamps for transient
if time_dim+'_stamp' in ncds.variables:
if lfeedback: print("\nTime-stamp variable ('{}_stamp') already exists.".format(time_dim))
else:
time_agg = time_agg.lower()
if time_agg.endswith('ly'): time_agg = time_agg[:-2]
if lfeedback: print("\nAdding human-readable time-stamp variable ('_stamp').".format(time_dim))
addTimeStamps(ncds, units=time_agg) # add time-stamps
## make sure the spatial units are present!!! xarray seems to loose the spatial coordinate units
lgeo = isGeoCRS(ncds, lraise=True)
for coord in getGeoCoords(ncds, lvars=True, lraise=True):
if 'units' not in coord.ncattrs():
coord.setncattr('units','deg' if lgeo else 'm')
# store geospatial code version
ncds.setncattr('geospatial_netcdf_version',geospatial_netcdf_version)
# replace original file
if ltmpfile:
if lfeedback: print("\nMoving file to final destination (overwriting old file):\n '{}'".format(filepath))
if os.path.exists(filepath): os.remove(filepath)
os.rename(tmp_filepath, filepath)
else:
# just show some info and save task graph
if lfeedback:
print("\nEncoding info:")
print(encoding)
print(task)
print("\nSaving task graph to:\n '{}.svg'".format(filepath))
task.visualize(filename=filepath+'.svg') # This file is never produced
# return file path
return filepath
if __name__ == '__main__':
pass | aerler/HGS-Tools | Python/geospatial/xarray_tools.py | Python | gpl-3.0 | 40,502 | 0.015234 |
#!/usr/bin/env python3.7
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import github3
import sys
githubent = github3.enterprise_login(
username=sys.argv[1],
password=sys.argv[2],
url=sys.argv[3])
for d in ["2014", "2015", "2016", "2017", "2018", "2019"]:
dateFilter = "created:<"+d+" and created:>"+str(int(d)-1)
for r in githubent.search_repositories("is:public and "+dateFilter):
print(d+","+r.clone_url)
| chrismattmann/drat | distribution/src/main/resources/bin/list-ghe-repos.py | Python | apache-2.0 | 1,171 | 0 |
from django_markup.filter import MarkupFilter
class MarkdownMarkupFilter(MarkupFilter):
"""
Applies Markdown conversion to a string, and returns the HTML.
"""
title = 'Markdown'
kwargs = {'safe_mode': True}
def render(self, text, **kwargs):
if kwargs:
self.kwargs.update(kwargs)
from markdown import markdown
text = markdown(text, **self.kwargs)
# Markdowns safe_mode is deprecated. We replace it with Bleach
# to keep it backwards compatible.
# https://python-markdown.github.io/change_log/release-2.6/#safe_mode-deprecated
if self.kwargs.get('safe_mode') is True:
from bleach import clean
# fmt: off
markdown_tags = [
"h1", "h2", "h3", "h4", "h5", "h6",
"b", "i", "strong", "em", "tt",
"p", "br",
"span", "div", "blockquote", "pre", "code", "hr",
"ul", "ol", "li", "dd", "dt",
"img",
"a",
"sub", "sup",
]
markdown_attrs = {
"*": ["id"],
"img": ["src", "alt", "title"],
"a": ["href", "alt", "title"],
}
# fmt: on
text = clean(text, markdown_tags, markdown_attrs)
return text
| bartTC/django-markup | django_markup/filter/markdown_filter.py | Python | bsd-3-clause | 1,360 | 0 |
'''
This module is part of ngs_backbone. This module provide mapping related
analyses
Created on 15/03/2010
@author: peio
'''
# Copyright 2009 Jose Blanca, Peio Ziarsolo, COMAV-Univ. Politecnica Valencia
# This file is part of franklin.
# franklin 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.
# franklin 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 franklin. If not, see <http://www.gnu.org/licenses/>.
import os, shutil
from gzip import GzipFile
from tempfile import NamedTemporaryFile
from franklin.backbone.analysis import (Analyzer, scrape_info_from_fname,
_LastAnalysisAnalyzer)
from franklin.mapping import map_reads
from franklin.utils.cmd_utils import call
from franklin.utils.misc_utils import (NamedTemporaryDir, VersionedPath,
rel_symlink)
from franklin.backbone.specifications import (BACKBONE_BASENAMES,
PLOT_FILE_FORMAT,
BACKBONE_DIRECTORIES)
from franklin.sam import (bam2sam, add_header_and_tags_to_sam, merge_sam,
sam2bam, sort_bam_sam, standardize_sam, realign_bam,
bam_distribs, create_bam_index, bam_general_stats)
class SetAssemblyAsReferenceAnalyzer(Analyzer):
'It sets the reference assembly as mapping reference'
def run(self):
'''It runs the analysis.'''
contigs_path = self._get_input_fpaths()['contigs']
contigs_ext = contigs_path.extension
reference_dir = self._create_output_dirs()['result']
reference_fpath = os.path.join(reference_dir,
BACKBONE_BASENAMES['mapping_reference'] + '.' + \
contigs_ext)
if os.path.exists(reference_fpath):
os.remove(reference_fpath)
rel_symlink(contigs_path.last_version, reference_fpath)
def _get_basename(fpath):
'It returns the base name without path and extension'
return os.path.splitext(os.path.basename(fpath))[0]
class MappingAnalyzer(Analyzer):
'It performs the mapping of the sequences to the reference'
def run(self):
'''It runs the analysis.'''
self._log({'analysis_started':True})
project_settings = self._project_settings
settings = project_settings['Mappers']
tmp_dir = project_settings['General_settings']['tmpdir']
project_path = project_settings['General_settings']['project_path']
unmapped_fhand = None
if 'keep_unmapped_reads_in_bam' in settings:
if settings['keep_unmapped_reads_in_bam'] == False:
unmapped_fpath = os.path.join(project_path,
BACKBONE_DIRECTORIES['mappings'][0],
BACKBONE_BASENAMES['unmapped_list'])
unmapped_fhand = GzipFile(unmapped_fpath, 'w')
inputs = self._get_input_fpaths()
reads_fpaths = inputs['reads']
output_dir = self._create_output_dirs(timestamped=True)['result']
# define color and sequence references
reference_path = inputs['reference']
mapping_index_dir = inputs['mapping_index']
#print reference_path, mapping_index_dir
#memory for the java programs
java_mem = self._project_settings['Other_settings']['java_memory']
picard_path = self._project_settings['Other_settings']['picard_path']
for read_fpath in reads_fpaths:
mapping_parameters = {}
read_info = scrape_info_from_fname(read_fpath)
platform = read_info['pl']
#which maper are we using for this platform
mapper = settings['mapper_for_%s' % platform]
(reference_fpath,
color_space) = self._prepare_mapper_index(mapping_index_dir,
reference_path,
platform, mapper)
mapping_parameters['unmapped_fhand'] = unmapped_fhand
mapping_parameters['colorspace'] = color_space
out_bam_fpath = os.path.join(output_dir,
read_fpath.basename + '.bam')
if platform in ('454', 'sanger'):
mapping_parameters['reads_length'] = 'long'
else:
mapping_parameters['reads_length'] = 'short'
if not os.path.exists(out_bam_fpath):
mapping_parameters['threads'] = self.threads
mapping_parameters['java_conf'] = {'java_memory':java_mem,
'picard_path':picard_path}
mapping_parameters['tmp_dir'] = tmp_dir
map_reads(mapper,
reads_fpath=read_fpath.last_version,
reference_fpath=reference_fpath,
out_bam_fpath=out_bam_fpath,
parameters=mapping_parameters)
# Now we run the select _last mapping
self._spawn_analysis(DEFINITIONS['_select_last_mapping'],
silent=self._silent)
self._log({'analysis_finished':True})
def _prepare_mapper_index(self, mapping_index_dir, reference_path, platform,
mapper):
'It creates reference_fpath depending on the mapper and the platform'
kind = 'color' if platform == 'solid' else 'sequence'
color_space = True if kind == 'color' else False
mapping_index_dir = mapping_index_dir[0].original_path
index_dir = mapping_index_dir % (mapper, kind)
if not os.path.exists(index_dir):
os.mkdir(index_dir)
reference_fpath = reference_path.last_version
reference_fname = os.path.basename(reference_fpath)
index_fpath = os.path.join(index_dir, reference_fname)
if not os.path.exists(index_fpath):
rel_symlink(reference_fpath, index_fpath)
return index_fpath, color_space
class MergeBamAnalyzer(Analyzer):
'It performs the merge of various bams into only one'
def run(self):
'''It runs the analysis.'''
self._log({'analysis_started':True})
settings = self._project_settings
project_path = settings['General_settings']['project_path']
tmp_dir = settings['General_settings']['tmpdir']
inputs = self._get_input_fpaths()
bam_paths = inputs['bams']
reference_path = inputs['reference']
output_dir = self._create_output_dirs()['result']
merged_bam_path = VersionedPath(os.path.join(output_dir,
BACKBONE_BASENAMES['merged_bam']))
merged_bam_fpath = merged_bam_path.next_version
#Do we have to add the default qualities to the sam file?
#do we have characters different from ACTGN?
add_qualities = settings['Sam_processing']['add_default_qualities']
#memory for the java programs
java_mem = settings['Other_settings']['java_memory']
picard_path = settings['Other_settings']['picard_path']
if add_qualities:
default_sanger_quality = settings['Other_settings']['default_sanger_quality']
default_sanger_quality = int(default_sanger_quality)
else:
default_sanger_quality = None
temp_dir = NamedTemporaryDir()
for bam_path in bam_paths:
bam_basename = bam_path.basename
temp_sam = NamedTemporaryFile(prefix='%s.' % bam_basename,
suffix='.sam')
sam_fpath = os.path.join(temp_dir.name, bam_basename + '.sam')
bam2sam(bam_path.last_version, temp_sam.name)
sam_fhand = open(sam_fpath, 'w')
# First we need to create the sam with added tags and headers
add_header_and_tags_to_sam(temp_sam, sam_fhand)
temp_sam.close()
sam_fhand.close()
#the standardization
temp_sam2 = NamedTemporaryFile(prefix='%s.' % bam_basename,
suffix='.sam', delete=False)
standardize_sam(open(sam_fhand.name), temp_sam2,
default_sanger_quality,
add_def_qual=add_qualities,
only_std_char=True)
temp_sam2.flush()
shutil.move(temp_sam2.name, sam_fhand.name)
temp_sam2.close()
get_sam_fpaths = lambda dir_: [os.path.join(dir_, fname) for fname in os.listdir(dir_) if fname.endswith('.sam')]
# Once the headers are ready we are going to merge
sams = get_sam_fpaths(temp_dir.name)
sams = [open(sam) for sam in sams]
temp_sam = NamedTemporaryFile(suffix='.sam')
reference_fhand = open(reference_path.last_version)
try:
merge_sam(sams, temp_sam, reference_fhand)
except Exception:
if os.path.exists(merged_bam_fpath):
os.remove(merged_bam_fpath)
raise
reference_fhand.close()
# close files
for sam in sams:
sam.close()
# Convert sam into a bam,(Temporary)
temp_bam = NamedTemporaryFile(suffix='.bam')
sam2bam(temp_sam.name, temp_bam.name)
# finally we need to order the bam
#print 'unsorted.bam', temp_bam.name
#raw_input()
sort_bam_sam(temp_bam.name, merged_bam_fpath,
java_conf={'java_memory':java_mem,
'picard_path':picard_path}, tmp_dir=tmp_dir )
temp_bam.close()
temp_sam.close()
create_bam_index(merged_bam_fpath)
self._log({'analysis_finished':True})
class CalmdBamAnalyzer(Analyzer):
'It runs samtools calmd '
def run(self):
'''It runs the analysis.'''
self._log({'analysis_started':True})
inputs = self._get_input_fpaths()
bam_path = inputs['bam']
bam_fpath = bam_path.last_version
reference_fpath = inputs['reference'].last_version
out_fhand = open(bam_path.next_version, 'w')
cmd = ['samtools', 'calmd', '-Abr', bam_fpath, reference_fpath]
call(cmd, raise_on_error=True, stdout=out_fhand)
create_bam_index(out_fhand.name)
out_fhand.close()
self._log({'analysis_finished':True})
class RealignBamAnalyzer(Analyzer):
'It realigns the bam using GATK'
def run(self):
'''It runs the analysis.'''
self._log({'analysis_started':True})
settings = self._project_settings
project_path = settings['General_settings']['project_path']
tmp_dir = settings['General_settings']['tmpdir']
inputs = self._get_input_fpaths()
bam_path = inputs['bam']
bam_fpath = bam_path.last_version
reference_path = inputs['reference']
#memory for the java programs
osettings = settings['Other_settings']
java_mem = osettings['java_memory']
picard_path = osettings['picard_path']
gatk_path = osettings['gatk_path']
#we need a temporary path
temp_bam = NamedTemporaryFile(suffix='.bam')
temp_bam_fpath = temp_bam.name
temp_bam.close()
#do the realigment
realign_bam(bam_fpath=bam_fpath,
reference_fpath=reference_path.last_version,
out_bam_fpath=temp_bam_fpath,
java_conf={'java_memory':java_mem,
'picard_path':picard_path,
'gatk_path':gatk_path},
threads=self.threads,
tmp_dir=tmp_dir)
#a new version for the original bam
out_bam_fpath = bam_path.next_version
shutil.move(temp_bam_fpath, out_bam_fpath)
self._log({'analysis_finished':True})
class BamStatsAnalyzer(Analyzer):
'It makes the stats of the mapping'
def run(self):
'''It runs the analysis.'''
self._log({'analysis_started':True})
settings = self._project_settings
self._create_output_dirs()['result']
project_name = settings['General_settings']['project_name']
sample_size = settings['Sam_stats']['sampling_size']
project_path = settings['General_settings']['project_path']
inputs = self._get_input_fpaths()
bam_path = inputs['bam']
bam_fpath = bam_path.last_version
bam_fhand = open(bam_fpath)
out_dir = os.path.abspath(self._get_output_dirs()['result'])
summary_fname = os.path.join(out_dir,
BACKBONE_BASENAMES['statistics_file'])
summary_fhand = open(summary_fname, 'w')
# non mapped_reads_fhand
unmapped_fpath = os.path.join(project_path,
BACKBONE_DIRECTORIES['mappings'][0],
BACKBONE_BASENAMES['unmapped_list'])
if os.path.exists(unmapped_fpath):
unmapped_fhand = GzipFile(unmapped_fpath)
else:
unmapped_fhand = None
#The general statistics
bam_general_stats(bam_fhand, summary_fhand, unmapped_fhand)
for kind in ('coverage', 'mapq'):
basename = os.path.join(out_dir, "%s" % (project_name))
bam_fhand.seek(0)
bam_distribs(bam_fhand, kind, basename=basename,
sample_size=sample_size, summary_fhand=summary_fhand,
plot_file_format=PLOT_FILE_FORMAT)
bam_fhand.close()
if unmapped_fhand is not None:
unmapped_fhand.close()
DEFINITIONS = {
'set_assembly_as_reference':
{'inputs':{
'contigs':
{'directory': 'assembly_result',
'file': 'contigs'},
},
'outputs':{'result':{'directory': 'mapping_reference'}},
'analyzer': SetAssemblyAsReferenceAnalyzer,
},
'mapping':
{'inputs':{
'reads':
{'directory': 'cleaned_reads',
'file_kinds': 'sequence_files'},
'reference':
{'directory': 'mapping_reference',
'file': 'mapping_reference'},
'mapping_index':
{'directory': 'mapping_index'},
},
'outputs':{'result':{'directory': 'mappings_by_readgroup'}},
'analyzer': MappingAnalyzer,
},
'_select_last_mapping':
{'inputs':{'analyses_dir':{'directory': 'mappings'}},
'outputs':{'result':{'directory': 'mapping_result',
'create':False}},
'analyzer': _LastAnalysisAnalyzer,
},
'merge_bams':
{'inputs':{
'bams':
{'directory': 'mappings_by_readgroup',
'file_kinds': 'bam'},
'reference':
{'directory': 'mapping_reference',
'file': 'mapping_reference'},
},
'outputs':{'result':{'directory': 'mapping_result'}},
'analyzer': MergeBamAnalyzer,
},
'realign_bam':
{'inputs':{
'bam':
{'directory': 'mapping_result',
'file': 'merged_bam'},
'reference':
{'directory': 'mapping_reference',
'file': 'mapping_reference'},
},
'outputs':{'result':{'directory': 'mapping_result'}},
'analyzer': RealignBamAnalyzer,
},
'calmd_bam':
{'inputs':{
'bam':
{'directory': 'mapping_result',
'file': 'merged_bam'},
'reference':
{'directory': 'mapping_reference',
'file': 'mapping_reference'},
},
'outputs':{'result':{'directory': 'mapping_result'}},
'analyzer': CalmdBamAnalyzer,
},
'mapping_stats':
{'inputs':{
'bam':
{'directory': 'mapping_result',
'file': 'merged_bam'},
},
'outputs':{'result':{'directory': 'mapping_stats'}},
'analyzer': BamStatsAnalyzer,
},
}
| JoseBlanca/franklin | franklin/backbone/mapping.py | Python | agpl-3.0 | 16,787 | 0.005957 |
import os
from setuptools import setup
from setuptools import find_packages
with open(os.path.join(os.path.dirname(__file__), 'README.md')) as readme:
README = readme.read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='liblinesdk',
version='0.1.0',
packages=find_packages(),
include_package_data=True,
license='BSD License', # example license
description='LINE API Python SDK.',
long_description=README,
url='https://www.example.com/',
author='LINE Corporation',
author_email='matthew.r.tanudjaja@linecorp.com',
classifiers=[
'Environment :: Web Environment',
'Framework :: Flask',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License', # example license
'Operating System :: OS Independent',
'Programming Language :: Python',
# Replace these appropriately if you are stuck on Python 2.
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
| mrexmelle/liblinesdk-py | setup.py | Python | mit | 1,211 | 0.000826 |
#* This file is part of the MOOSE framework
#* https://www.mooseframework.org
#*
#* All rights reserved, see COPYRIGHT for full restrictions
#* https://github.com/idaholab/moose/blob/master/COPYRIGHT
#*
#* Licensed under LGPL 2.1, please see LICENSE for details
#* https://www.gnu.org/licenses/lgpl-2.1.html
import uuid
import collections
import moosetree
import MooseDocs
from ..common import exceptions
from ..base import components, MarkdownReader, LatexRenderer, Extension
from ..tree import tokens, html, latex
from . import core
def make_extension(**kwargs):
return FloatExtension(**kwargs)
Float = tokens.newToken('Float', img=False, bottom=False, command='figure')
FloatCaption = tokens.newToken('FloatCaption', key='', prefix='', number='?')
ModalLink = tokens.newToken('ModalLink', bookmark=True, bottom=False, close=True)
ModalLinkTitle = tokens.newToken('ModalLinkTitle')
ModalLinkContent = tokens.newToken('ModalLinkContent')
def create_float(parent, extension, reader, page, settings, bottom=False, img=False,
token_type=Float, **kwargs):
"""
Helper for optionally creating a float based on the existence of caption and/or id.
Inputs:
parent: The parent token that float should be placed
extension: The extension object (to extract 'prefix' from config items)
reader: The Reader object for tokenization of the heading
page: The Page object for passing to the tokenization routine
settings: The command settings to extract a local 'prefix'
bottom[True|False]: Set flag on the float for placing the caption at the bottom
img[True|False]: Set to True if the contents are an image (Materialize only)
token_type: The type of Token object to create; it should derive from Float
"""
cap, _ = _add_caption(None, extension, reader, page, settings)
if cap:
flt = token_type(parent, img=img, bottom=bottom, **kwargs)
cap.parent = flt
return flt
return parent
def caption_settings():
"""Return settings necessary for captions."""
settings = dict()
settings['caption'] = (None, "The caption text for the float object.")
settings['prefix'] = (None, "The numbered caption label to include prior to the caption text.")
return settings
def _add_caption(parent, extension, reader, page, settings):
"""Helper for adding captions to float tokens."""
cap = settings['caption']
key = settings['id']
prefix = settings.get('prefix')
if prefix is None:
prefix = extension.get('prefix', None)
if prefix is None:
msg = "The 'prefix' must be supplied via the settings or the extension configuration."
raise exceptions.MooseDocsException(msg)
caption = None
if key:
caption = FloatCaption(parent, key=key, prefix=prefix)
if cap:
reader.tokenize(caption, cap, page, MarkdownReader.INLINE)
elif cap:
caption = FloatCaption(parent)
reader.tokenize(caption, cap, page, MarkdownReader.INLINE)
return caption, prefix
def create_modal(parent, title=None, content=None, **kwargs):
"""
Create the necessary Modal tokens for creating modal windows with materialize.
"""
modal = ModalLink(parent.root, **kwargs)
if isinstance(title, str):
ModalLinkTitle(modal, string=title)
elif isinstance(title, tokens.Token):
title.parent = ModalLinkTitle(modal)
if isinstance(content, str):
ModalLinkContent(modal, string=content)
elif isinstance(content, tokens.Token):
content.parent = ModalLinkContent(modal)
return parent
def create_modal_link(parent, title=None, content=None, string=None, **kwargs):
"""
Create the necessary tokens to create a link to a modal window with materialize.
"""
kwargs.setdefault('bookmark', str(uuid.uuid4()))
link = core.Link(parent,
url='#{}'.format(kwargs['bookmark']),
class_='modal-trigger',
string=string)
create_modal(parent, title, content, **kwargs)
return link
class FloatExtension(Extension):
"""
Provides ability to add caption float elements (e.g., figures, table, etc.). This is only a
base extension. It does not provide tables for example, just the tools to make floats
in a uniform manner.
"""
def extend(self, reader, renderer):
renderer.add('Float', RenderFloat())
renderer.add('FloatCaption', RenderFloatCaption())
renderer.add('ModalLink', RenderModalLink())
renderer.add('ModalLinkTitle', RenderModalLinkTitle())
renderer.add('ModalLinkContent', RenderModalLinkContent())
if isinstance(renderer, LatexRenderer):
renderer.addPackage('caption', labelsep='period')
def postTokenize(self, page, ast):
"""Set float number for each counter."""
counts = page.get('counts', collections.defaultdict(int))
for node in moosetree.iterate(ast, lambda n: n.name == 'FloatCaption'):
prefix = node.get('prefix', None)
if prefix is not None:
counts[prefix] += 1
node['number'] = counts[prefix]
key = node.get('key')
if key:
shortcut = core.Shortcut(ast.root, key=key, link='#{}'.format(key))
# TODO: This is a bit of a hack to get Figure~\ref{} etc. working in general
if isinstance(self.translator.renderer, LatexRenderer):
shortcut['prefix'] = prefix.title()
else:
tokens.String(shortcut, content='{} {}'.format(prefix.title(), node['number']))
page['counts'] = counts
class RenderFloat(components.RenderComponent):
def createHTML(self, parent, token, page):
div = html.Tag(parent, 'div', token)
div.addClass('moose-float-div')
if token['bottom']:
cap = token(0)
cap.parent = None # Guarantees that "cap" is removed from the current tree
cap.parent = token
return div
def createMaterialize(self, parent, token, page):
div = html.Tag(parent, 'div', token)
div.addClass('card moose-float')
content = html.Tag(div, 'div')
if token['img']:
content.addClass('card-image')
else:
content.addClass('card-content')
if token['bottom']:
cap = token(0)
cap.parent = None
cap.parent = token
return content
def createLatex(self, parent, token, page):
env = latex.Environment(parent, token['command'])
style = latex.parse_style(token)
width = style.get('width', None)
if width and token(0).name == 'Image':
token(0).set('style', 'width:{};'.format(width))
if style.get('text-align', None) == 'center':
latex.Command(env, 'centering')
return env
class RenderFloatCaption(components.RenderComponent):
def createHTML(self, parent, token, page):
caption = html.Tag(parent, 'p', class_="moose-caption")
prefix = token.get('prefix', None)
if prefix:
heading = html.Tag(caption, 'span', class_="moose-caption-heading")
html.String(heading, content="{} {}: ".format(prefix, token['number']))
return html.Tag(caption, 'span', class_="moose-caption-text")
def createLatex(self, parent, token, page):
caption = latex.Command(parent, 'caption')
if token['key']:
latex.Command(caption, 'label', string=token['key'], escape=True)
return caption
class RenderModalLink(core.RenderLink):
def createLatex(self, parent, token, page):
return None
def createHTML(self, parent, token, page):
return None
def createMaterialize(self, parent, token, page):
cls = "modal bottom-sheet" if token['bottom'] else "modal"
modal = html.Tag(parent, 'div', class_=cls, id_=token['bookmark'])
modal.addClass('moose-modal')
modal_content = html.Tag(modal, 'div', class_="modal-content")
if token['close']:
footer = html.Tag(modal, 'div', class_='modal-footer')
html.Tag(footer, 'a', class_='modal-close btn-flat', string='Close')
return modal_content
class RenderModalLinkTitle(components.RenderComponent):
def createHTML(self, parent, token, page):
return None
def createMaterialize(self, parent, token, page):
return html.Tag(parent, 'h4')
def createLatex(self, parent, token, page):
return None
class RenderModalLinkContent(components.RenderComponent):
def createHTML(self, parent, token, page):
return None
def createMaterialize(self, parent, token, page):
return parent
def createLatex(self, parent, token, page):
return None
| nuclear-wizard/moose | python/MooseDocs/extensions/floats.py | Python | lgpl-2.1 | 8,900 | 0.004494 |
# Copyright (c) 2016 VMware, 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.
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
import json
import sqlalchemy as sa
from sqlalchemy.orm import exc as db_exc
from congress.db import api as db
from congress.db import model_base
from congress.db import utils as db_utils
class DSTableData(model_base.BASE):
__tablename__ = 'dstabledata'
ds_id = sa.Column(sa.String(36), nullable=False, primary_key=True)
tablename = sa.Column(sa.String(255), nullable=False, primary_key=True)
# choose long length compatible with MySQL, SQLite, Postgres
tabledata = sa.Column(sa.Text(), nullable=False)
@db_utils.retry_on_db_error
def store_ds_table_data(ds_id, tablename, tabledata, session=None):
session = session or db.get_session()
tabledata = _json_encode_table_data(tabledata)
with session.begin(subtransactions=True):
new_row = session.merge(DSTableData(
ds_id=ds_id,
tablename=tablename,
tabledata=tabledata))
return new_row
@db_utils.retry_on_db_error
def delete_ds_table_data(ds_id, tablename=None, session=None):
session = session or db.get_session()
if tablename is None:
return session.query(DSTableData).filter(
DSTableData.ds_id == ds_id).delete()
else:
return session.query(DSTableData).filter(
DSTableData.ds_id == ds_id,
DSTableData.tablename == tablename).delete()
@db_utils.retry_on_db_error
def get_ds_table_data(ds_id, tablename=None, session=None):
session = session or db.get_session()
try:
if tablename is None:
rows = session.query(DSTableData).filter(
DSTableData.ds_id == ds_id)
return_list = []
for row in rows:
return_list.append(
{'tablename': row.tablename,
'tabledata': _json_decode_table_data(row.tabledata)})
return return_list
else:
return _json_decode_table_data(session.query(DSTableData).filter(
DSTableData.ds_id == ds_id,
DSTableData.tablename == tablename).one().tabledata)
except db_exc.NoResultFound:
pass
def _json_encode_table_data(tabledata):
tabledata = list(tabledata)
for i in range(0, len(tabledata)):
tabledata[i] = list(tabledata[i])
return json.dumps(tabledata)
def _json_decode_table_data(json_tabledata):
tabledata = json.loads(json_tabledata)
for i in range(0, len(tabledata)):
tabledata[i] = tuple(tabledata[i])
return set(tabledata)
| openstack/congress | congress/db/db_ds_table_data.py | Python | apache-2.0 | 3,233 | 0 |
"""Automatic keyboard layout switcher"""
import functools
import logging
import subprocess
from typing import Iterable
from typing import Set
import xkbgroup
import swytcher.settings as settings
import swytcher.xwindow as xwindow
from swytcher.util import suppress_err
log = logging.getLogger(__name__) # pylint: disable=invalid-name
# Move this to swytcher.system
@suppress_err(FileNotFoundError, log)
def notify(title: str, msg: str = '') -> None: # pragma: no cover
"""Use notify-send (if available) to inform user of layout switch."""
if not settings.NOTIFY:
return
cmd = [
'notify-send',
'--urgency=low',
'--expire-time=2000',
title,
msg
]
subprocess.call(cmd)
def change_layout(xkb: xkbgroup.XKeyboard, layout: str) -> bool:
"""Set layout; returns True if layout was changed, False otherwise"""
if xkb.group_name == layout: # check against current layout
log.debug("%r is already the active layout", layout)
return False # don't change layout if it's already correct
log.info("setting layout %r", layout)
xkb.group_name = layout
notify("Changed layout", layout)
return True
def _match_substrings(name_list: Iterable[str],
substrings: Iterable[str]) -> set:
"""Substring filter match"""
found_matches = set()
for name in name_list:
for substring in substrings:
if substring in name:
log.debug("Substring filter match: %r in %r", substring, name)
found_matches.update([name])
return found_matches
def matches(name_list: Iterable[str], strings: Iterable[str],
substrings: Iterable[str]) -> Set[str]:
"""Returns True if any of the strings in the two filters `strings` and
`substrings` occur in `name_list`."""
matched = (set(strings) & set(name_list) or
_match_substrings(name_list, substrings or {}))
if matched:
log.debug('%r matched %r from %r or %r',
name_list, matched, strings, substrings)
return matched
def change_callback(name_list, xkb, layouts: list) -> None: # pragma: no cover
"""Event handler when active window is changed"""
# NOTE: These extracted variables should be removed later
primary_filter = layouts[0]['strings']
primary_substrings = layouts[0]['substrings']
primary = layouts[0]['name']
secondary_filter = layouts[1]['strings']
secondary_substrings = layouts[1]['substrings']
secondary = layouts[1]['name']
# matched_layout = match_layout(name_list, layouts)
# if matched_layout:
# change_layout(xkb, matched_layout)
# else:
# change_layout(xkb, last_remembered_layout_for_window)
if matches(name_list, secondary_filter, secondary_substrings):
change_layout(xkb, secondary)
elif matches(name_list, primary_filter, primary_substrings):
change_layout(xkb, primary)
else:
log.debug("%r: No match, using default layout", name_list)
change_layout(xkb, xkb.groups_names[0])
def main(args=None): # pragma: no cover
"""Main"""
if not args:
pass
xkb = xkbgroup.XKeyboard()
layouts = settings.setup_layouts(xkb, settings.CONFIG_INI)
log.info("Layouts configured by setxkbmap: %s", layouts)
partial_cb = functools.partial(change_callback, xkb=xkb, layouts=layouts)
xwindow.run(partial_cb)
| eddie-dunn/swytcher | swytcher/swytcher.py | Python | mit | 3,436 | 0 |
# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding field 'Project.version_privacy_level'
db.add_column('projects_project', 'version_privacy_level',
self.gf('django.db.models.fields.CharField')(default='public', max_length=20),
keep_default=False)
def backwards(self, orm):
# Deleting field 'Project.version_privacy_level'
db.delete_column('projects_project', 'version_privacy_level')
models = {
'auth.group': {
'Meta': {'object_name': 'Group'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
'auth.permission': {
'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 10, 13, 23, 55, 17, 885486)'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 10, 13, 23, 55, 17, 885212)'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'projects.importedfile': {
'Meta': {'object_name': 'ImportedFile'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'md5': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'path': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'imported_files'", 'to': "orm['projects.Project']"}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '50'})
},
'projects.project': {
'Meta': {'ordering': "('slug',)", 'object_name': 'Project'},
'analytics_code': ('django.db.models.fields.CharField', [], {'max_length': '50', 'null': 'True', 'blank': 'True'}),
'conf_py_file': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '255', 'blank': 'True'}),
'copyright': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'crate_url': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'default_branch': ('django.db.models.fields.CharField', [], {'default': 'None', 'max_length': '255', 'null': 'True', 'blank': 'True'}),
'default_version': ('django.db.models.fields.CharField', [], {'default': "'latest'", 'max_length': '255'}),
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'django_packages_url': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'documentation_type': ('django.db.models.fields.CharField', [], {'default': "'sphinx'", 'max_length': '20'}),
'featured': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'modified_date': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'path': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'privacy_level': ('django.db.models.fields.CharField', [], {'default': "'public'", 'max_length': '20'}),
'project_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'pub_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'related_projects': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['projects.Project']", 'null': 'True', 'through': "orm['projects.ProjectRelationship']", 'blank': 'True'}),
'repo': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'repo_type': ('django.db.models.fields.CharField', [], {'default': "'git'", 'max_length': '10'}),
'requirements_file': ('django.db.models.fields.CharField', [], {'default': 'None', 'max_length': '255', 'null': 'True', 'blank': 'True'}),
'skip': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '255'}),
'suffix': ('django.db.models.fields.CharField', [], {'default': "'.rst'", 'max_length': '10'}),
'theme': ('django.db.models.fields.CharField', [], {'default': "'default'", 'max_length': '20'}),
'use_system_packages': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'use_virtualenv': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'users': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'projects'", 'symmetrical': 'False', 'to': "orm['auth.User']"}),
'version': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'version_privacy_level': ('django.db.models.fields.CharField', [], {'default': "'public'", 'max_length': '20'})
},
'projects.projectrelationship': {
'Meta': {'object_name': 'ProjectRelationship'},
'child': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'superprojects'", 'to': "orm['projects.Project']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'parent': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'subprojects'", 'to': "orm['projects.Project']"})
},
'taggit.tag': {
'Meta': {'object_name': 'Tag'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '100'})
},
'taggit.taggeditem': {
'Meta': {'object_name': 'TaggedItem'},
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'taggit_taggeditem_tagged_items'", 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'object_id': ('django.db.models.fields.IntegerField', [], {'db_index': 'True'}),
'tag': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'taggit_taggeditem_items'", 'to': "orm['taggit.Tag']"})
}
}
complete_apps = ['projects']
| d0ugal/readthedocs.org | readthedocs/projects/migrations/0028_add_version_default_privacy.py | Python | mit | 9,508 | 0.007678 |
"Yang/Wu's OEP implementation, in PyQuante."
from math import sqrt
import settings
from PyQuante.NumWrap import zeros,matrixmultiply,transpose,dot,identity,\
array,solve
from PyQuante.Ints import getbasis, getints, getJ,get2JmK,getK
from PyQuante.LA2 import geigh,mkdens,trace2,simx
from PyQuante.hartree_fock import get_fock
from PyQuante.CGBF import three_center
from PyQuante.optimize import fminBFGS
from PyQuante.fermi_dirac import get_efermi, get_fermi_occs,mkdens_occs,\
get_entropy,mkdens_fermi
import logging
logger = logging.getLogger("pyquante")
gradcall=0
class EXXSolver:
"EXXSolver(solver)"
def __init__(self,solver):
# Solver is a pointer to a HF or a DFT calculation that has
# already converged
self.solver = solver
self.bfs = self.solver.bfs
self.nbf = len(self.bfs)
self.S = self.solver.S
self.h = self.solver.h
self.Ints = self.solver.Ints
self.molecule = self.solver.molecule
self.nel = self.molecule.get_nel()
self.nclosed, self.nopen = self.molecule.get_closedopen()
self.Enuke = self.molecule.get_enuke()
self.norb = self.nbf
self.orbs = self.solver.orbs
self.orbe = self.solver.orbe
self.Gij = []
for g in xrange(self.nbf):
gmat = zeros((self.nbf,self.nbf),'d')
self.Gij.append(gmat)
gbf = self.bfs[g]
for i in xrange(self.nbf):
ibf = self.bfs[i]
for j in xrange(i+1):
jbf = self.bfs[j]
gij = three_center(ibf,gbf,jbf)
gmat[i,j] = gij
gmat[j,i] = gij
D0 = mkdens(self.orbs,0,self.nclosed)
J0 = getJ(self.Ints,D0)
Vfa = (2.0*(self.nel-1.0)/self.nel)*J0
self.H0 = self.h + Vfa
self.b = zeros(self.nbf,'d')
return
def iterate(self,**kwargs):
self.iter = 0
self.etemp = kwargs.get("etemp",settings.DFTElectronTemperature)
logging.debug("iter Energy <b|b>")
logging.debug("---- ------ -----")
self.b = fminBFGS(self.get_energy,self.b,self.get_gradient,logger=logging)
return
def get_energy(self,b):
self.iter += 1
self.Hoep = get_Hoep(b,self.H0,self.Gij)
self.orbe,self.orbs = geigh(self.Hoep,self.S)
if self.etemp:
self.D,self.entropy = mkdens_fermi(self.nel,self.orbe,self.orbs,
self.etemp)
else:
self.D = mkdens(self.orbs,0,self.nclosed)
self.entropy=0
self.F = get_fock(self.D,self.Ints,self.h)
self.energy = trace2(self.h+self.F,self.D)+self.Enuke + self.entropy
if self.iter == 1 or self.iter % 10 == 0:
logging.debug("%4d %10.5f %10.5f" % (self.iter,self.energy,dot(b,b)))
return self.energy
def get_gradient(self,b):
energy = self.get_energy(b)
Fmo = simx(self.F,self.orbs)
bp = zeros(self.nbf,'d')
for g in xrange(self.nbf):
# Transform Gij[g] to MOs. This is done over the whole
# space rather than just the parts we need. I can speed
# this up later by only forming the i,a elements required
Gmo = simx(self.Gij[g],self.orbs)
# Now sum the appropriate terms to get the b gradient
for i in xrange(self.nclosed):
for a in xrange(self.nclosed,self.norb):
bp[g] = bp[g] + Fmo[i,a]*Gmo[i,a]/(self.orbe[i]-self.orbe[a])
#logging.debug("EXX Grad: %10.5f" % (sqrt(dot(bp,bp))))
return bp
class UEXXSolver:
"EXXSolver(solver)"
def __init__(self,solver):
# Solver is a pointer to a UHF calculation that has
# already converged
self.solver = solver
self.bfs = self.solver.bfs
self.nbf = len(self.bfs)
self.S = self.solver.S
self.h = self.solver.h
self.Ints = self.solver.Ints
self.molecule = self.solver.molecule
self.nel = self.molecule.get_nel()
self.nalpha, self.nbeta = self.molecule.get_alphabeta()
self.Enuke = self.molecule.get_enuke()
self.norb = self.nbf
self.orbsa = self.solver.orbsa
self.orbsb = self.solver.orbsb
self.orbea = self.solver.orbea
self.orbeb = self.solver.orbeb
self.Gij = []
for g in xrange(self.nbf):
gmat = zeros((self.nbf,self.nbf),'d')
self.Gij.append(gmat)
gbf = self.bfs[g]
for i in xrange(self.nbf):
ibf = self.bfs[i]
for j in xrange(i+1):
jbf = self.bfs[j]
gij = three_center(ibf,gbf,jbf)
gmat[i,j] = gij
gmat[j,i] = gij
D0 = mkdens(self.orbsa,0,self.nalpha)+mkdens(self.orbsb,0,self.nbeta)
J0 = getJ(self.Ints,D0)
Vfa = ((self.nel-1.)/self.nel)*J0
self.H0 = self.h + Vfa
self.b = zeros(2*self.nbf,'d')
return
def iterate(self,**kwargs):
self.etemp = kwargs.get("etemp",settings.DFTElectronTemperature)
self.iter = 0
logging.debug("iter Energy <b|b>")
logging.debug("---- ------ -----")
self.b = fminBFGS(self.get_energy,self.b,self.get_gradient,logger=logging)
return
def get_energy(self,b):
self.iter += 1
ba = b[:self.nbf]
bb = b[self.nbf:]
self.Hoepa = get_Hoep(ba,self.H0,self.Gij)
self.Hoepb = get_Hoep(bb,self.H0,self.Gij)
self.orbea,self.orbsa = geigh(self.Hoepa,self.S)
self.orbeb,self.orbsb = geigh(self.Hoepb,self.S)
if self.etemp:
self.Da,entropya = mkdens_fermi(2*self.nalpha,self.orbea,self.orbsa,
self.etemp)
self.Db,entropyb = mkdens_fermi(2*self.nbeta,self.orbeb,self.orbsb,
self.etemp)
self.entropy = 0.5*(entropya+entropyb)
else:
self.Da = mkdens(self.orbsa,0,self.nalpha)
self.Db = mkdens(self.orbsb,0,self.nbeta)
self.entropy=0
J = getJ(self.Ints,self.Da+self.Db)
Ka = getK(self.Ints,self.Da)
Kb = getK(self.Ints,self.Db)
self.Fa = self.h + J - Ka
self.Fb = self.h + J - Kb
self.energy = 0.5*(trace2(self.h+self.Fa,self.Da) +
trace2(self.h+self.Fb,self.Db))\
+ self.Enuke + self.entropy
if self.iter == 1 or self.iter % 10 == 0:
logging.debug("%4d %10.5f %10.5f" % (self.iter,self.energy,dot(b,b)))
return self.energy
def get_gradient(self,b):
energy = self.get_energy(b)
Fmoa = simx(self.Fa,self.orbsa)
Fmob = simx(self.Fb,self.orbsb)
bp = zeros(2*self.nbf,'d')
for g in xrange(self.nbf):
# Transform Gij[g] to MOs. This is done over the whole
# space rather than just the parts we need. I can speed
# this up later by only forming the i,a elements required
Gmo = simx(self.Gij[g],self.orbsa)
# Now sum the appropriate terms to get the b gradient
for i in xrange(self.nalpha):
for a in xrange(self.nalpha,self.norb):
bp[g] += Fmoa[i,a]*Gmo[i,a]/(self.orbea[i]-self.orbea[a])
for g in xrange(self.nbf):
# Transform Gij[g] to MOs. This is done over the whole
# space rather than just the parts we need. I can speed
# this up later by only forming the i,a elements required
Gmo = simx(self.Gij[g],self.orbsb)
# Now sum the appropriate terms to get the b gradient
for i in xrange(self.nbeta):
for a in xrange(self.nbeta,self.norb):
bp[self.nbf+g] += Fmob[i,a]*Gmo[i,a]/(self.orbeb[i]-self.orbeb[a])
#logging.debug("EXX Grad: %10.5f" % (sqrt(dot(bp,bp))))
return bp
def exx(atoms,orbs,**kwargs):
return oep_hf(atoms,orbs,**kwargs)
def oep_hf(atoms,orbs,**kwargs):
"""oep_hf - Form the optimized effective potential for HF exchange.
See notes on options and other args in oep routine.
"""
return oep(atoms,orbs,get_exx_energy,get_exx_gradient,**kwargs)
def oep(atoms,orbs,energy_func,grad_func=None,**kwargs):
"""oep - Form the optimized effective potential for a given energy expression
oep(atoms,orbs,energy_func,grad_func=None,**kwargs)
atoms A Molecule object containing a list of the atoms
orbs A matrix of guess orbitals
energy_func The function that returns the energy for the given method
grad_func The function that returns the force for the given method
Options
-------
verbose False Output terse information to stdout (default)
True Print out additional information
ETemp False Use ETemp value for finite temperature DFT (default)
float Use (float) for the electron temperature
bfs None The basis functions to use. List of CGBF's
basis_data None The basis data to use to construct bfs
integrals None The one- and two-electron integrals to use
If not None, S,h,Ints
"""
verbose = kwargs.get('verbose')
ETemp = kwargs.get('ETemp',settings.DFTElectronTemperature)
opt_method = kwargs.get('opt_method',settings.OEPOptMethod)
bfs = getbasis(atoms,**kwargs)
# The basis set for the potential can be set different from
# that used for the wave function
pbfs = kwargs.get('pbfs')
if not pbfs: pbfs = bfs
npbf = len(pbfs)
S,h,Ints = getints(bfs,atoms,**kwargs)
nel = atoms.get_nel()
nocc,nopen = atoms.get_closedopen()
Enuke = atoms.get_enuke()
# Form the OEP using Yang/Wu, PRL 89 143002 (2002)
nbf = len(bfs)
norb = nbf
bp = zeros(nbf,'d')
bvec = kwargs.get('bvec')
if bvec:
assert len(bvec) == npbf
b = array(bvec)
else:
b = zeros(npbf,'d')
# Form and store all of the three-center integrals
# we're going to need.
# These are <ibf|gbf|jbf> (where 'bf' indicates basis func,
# as opposed to MO)
# N^3 storage -- obviously you don't want to do this for
# very large systems
Gij = []
for g in xrange(npbf):
gmat = zeros((nbf,nbf),'d')
Gij.append(gmat)
gbf = pbfs[g]
for i in xrange(nbf):
ibf = bfs[i]
for j in xrange(i+1):
jbf = bfs[j]
gij = three_center(ibf,gbf,jbf)
gmat[i,j] = gij
gmat[j,i] = gij
# Compute the Fermi-Amaldi potential based on the LDA density.
# We're going to form this matrix from the Coulombic matrix that
# arises from the input orbitals. D0 and J0 refer to the density
# matrix and corresponding Coulomb matrix
D0 = mkdens(orbs,0,nocc)
J0 = getJ(Ints,D0)
Vfa = (2*(nel-1.)/nel)*J0
H0 = h + Vfa
b = fminBFGS(energy_func,b,grad_func,
(nbf,nel,nocc,ETemp,Enuke,S,h,Ints,H0,Gij),
logger=logging)
energy,orbe,orbs = energy_func(b,nbf,nel,nocc,ETemp,Enuke,
S,h,Ints,H0,Gij,return_flag=1)
return energy,orbe,orbs
def get_exx_energy(b,nbf,nel,nocc,ETemp,Enuke,S,h,Ints,H0,Gij,**kwargs):
"""Computes the energy for the OEP/HF functional
Options:
return_flag 0 Just return the energy
1 Return energy, orbe, orbs
2 Return energy, orbe, orbs, F
"""
return_flag = kwargs.get('return_flag')
Hoep = get_Hoep(b,H0,Gij)
orbe,orbs = geigh(Hoep,S)
if ETemp:
efermi = get_efermi(nel,orbe,ETemp)
occs = get_fermi_occs(efermi,orbe,ETemp)
D = mkdens_occs(orbs,occs)
entropy = get_entropy(occs,ETemp)
else:
D = mkdens(orbs,0,nocc)
F = get_fock(D,Ints,h)
energy = trace2(h+F,D)+Enuke
if ETemp: energy += entropy
iref = nel/2
gap = 627.51*(orbe[iref]-orbe[iref-1])
logging.debug("EXX Energy, B, Gap: %10.5f %10.5f %10.5f"
% (energy,sqrt(dot(b,b)),gap))
#logging.debug("%s" % orbe)
if return_flag == 1:
return energy,orbe,orbs
elif return_flag == 2:
return energy,orbe,orbs,F
return energy
def get_exx_gradient(b,nbf,nel,nocc,ETemp,Enuke,S,h,Ints,H0,Gij,**kwargs):
"""Computes the gradient for the OEP/HF functional.
return_flag 0 Just return gradient
1 Return energy,gradient
2 Return energy,gradient,orbe,orbs
"""
# Dump the gradient every 10 steps so we can restart...
global gradcall
gradcall += 1
#if gradcall % 5 == 0: logging.debug("B vector:\n%s" % b)
# Form the new potential and the new orbitals
energy,orbe,orbs,F = get_exx_energy(b,nbf,nel,nocc,ETemp,Enuke,
S,h,Ints,H0,Gij,return_flag=2)
Fmo = matrixmultiply(transpose(orbs),matrixmultiply(F,orbs))
norb = nbf
bp = zeros(nbf,'d') # dE/db
for g in xrange(nbf):
# Transform Gij[g] to MOs. This is done over the whole
# space rather than just the parts we need. I can speed
# this up later by only forming the i,a elements required
Gmo = matrixmultiply(transpose(orbs),matrixmultiply(Gij[g],orbs))
# Now sum the appropriate terms to get the b gradient
for i in xrange(nocc):
for a in xrange(nocc,norb):
bp[g] = bp[g] + Fmo[i,a]*Gmo[i,a]/(orbe[i]-orbe[a])
#logging.debug("EXX Grad: %10.5f" % (sqrt(dot(bp,bp))))
return_flag = kwargs.get('return_flag')
if return_flag == 1:
return energy,bp
elif return_flag == 2:
return energy,bp,orbe,orbs
return bp
def get_Hoep(b,H0,Gij):
Hoep = H0
# Add the contributions from the gaussian potential functions
# H[ij] += b[g]*<ibf|g|jbf>
for g in xrange(len(b)):
Hoep = Hoep + b[g]*Gij[g]
return Hoep
# Here's a much faster way to do this. Haven't figured out how to
# do it for more generic functions like OEP-GVB
def oep_hf_an(atoms,orbs,**kwargs):
"""oep_hf - Form the optimized effective potential for HF exchange.
Implementation of Wu and Yang's Approximate Newton Scheme
from J. Theor. Comp. Chem. 2, 627 (2003).
oep_hf(atoms,orbs,**kwargs)
atoms A Molecule object containing a list of the atoms
orbs A matrix of guess orbitals
Options
-------
bfs None The basis functions to use for the wfn
pbfs None The basis functions to use for the pot
basis_data None The basis data to use to construct bfs
integrals None The one- and two-electron integrals to use
If not None, S,h,Ints
"""
maxiter = kwargs.get('maxiter',settings.OEPIters)
tol = kwargs.get('tol',settings.OEPTolerance)
bfs = getbasis(atoms,**kwargs)
# The basis set for the potential can be set different from
# that used for the wave function
pbfs = kwargs.get('pbfs')
if not pbfs: pbfs = bfs
npbf = len(pbfs)
S,h,Ints = getints(bfs,atoms)
nel = atoms.get_nel()
nocc,nopen = atoms.get_closedopen()
Enuke = atoms.get_enuke()
# Form the OEP using Yang/Wu, PRL 89 143002 (2002)
nbf = len(bfs)
norb = nbf
bp = zeros(nbf,'d')
bvec = kwargs.get('bvec')
if bvec:
assert len(bvec) == npbf
b = array(bvec)
else:
b = zeros(npbf,'d')
# Form and store all of the three-center integrals
# we're going to need.
# These are <ibf|gbf|jbf> (where 'bf' indicates basis func,
# as opposed to MO)
# N^3 storage -- obviously you don't want to do this for
# very large systems
Gij = []
for g in xrange(npbf):
gmat = zeros((nbf,nbf),'d')
Gij.append(gmat)
gbf = pbfs[g]
for i in xrange(nbf):
ibf = bfs[i]
for j in xrange(i+1):
jbf = bfs[j]
gij = three_center(ibf,gbf,jbf)
gmat[i,j] = gij
gmat[j,i] = gij
# Compute the Fermi-Amaldi potential based on the LDA density.
# We're going to form this matrix from the Coulombic matrix that
# arises from the input orbitals. D0 and J0 refer to the density
# matrix and corresponding Coulomb matrix
D0 = mkdens(orbs,0,nocc)
J0 = getJ(Ints,D0)
Vfa = (2*(nel-1.)/nel)*J0
H0 = h + Vfa
b = zeros(nbf,'d')
eold = 0
for iter in xrange(maxiter):
Hoep = get_Hoep(b,H0,Gij)
orbe,orbs = geigh(Hoep,S)
D = mkdens(orbs,0,nocc)
Vhf = get2JmK(Ints,D)
energy = trace2(2*h+Vhf,D)+Enuke
if abs(energy-eold) < tol:
break
else:
eold = energy
logging.debug("OEP AN Opt: %d %f" % (iter,energy))
dV_ao = Vhf-Vfa
dV = matrixmultiply(transpose(orbs),matrixmultiply(dV_ao,orbs))
X = zeros((nbf,nbf),'d')
c = zeros(nbf,'d')
Gkt = zeros((nbf,nbf),'d')
for k in xrange(nbf):
# This didn't work; in fact, it made things worse:
Gk = matrixmultiply(transpose(orbs),matrixmultiply(Gij[k],orbs))
for i in xrange(nocc):
for a in xrange(nocc,norb):
c[k] += dV[i,a]*Gk[i,a]/(orbe[i]-orbe[a])
for l in xrange(nbf):
Gl = matrixmultiply(transpose(orbs),matrixmultiply(Gij[l],orbs))
for i in xrange(nocc):
for a in xrange(nocc,norb):
X[k,l] += Gk[i,a]*Gl[i,a]/(orbe[i]-orbe[a])
# This should actually be a pseudoinverse...
b = solve(X,c)
logger.info("Final OEP energy = %f" % energy)
return energy,orbe,orbs
def oep_uhf_an(atoms,orbsa,orbsb,**kwargs):
"""oep_hf - Form the optimized effective potential for HF exchange.
Implementation of Wu and Yang's Approximate Newton Scheme
from J. Theor. Comp. Chem. 2, 627 (2003).
oep_uhf(atoms,orbs,**kwargs)
atoms A Molecule object containing a list of the atoms
orbs A matrix of guess orbitals
Options
-------
bfs None The basis functions to use for the wfn
pbfs None The basis functions to use for the pot
basis_data None The basis data to use to construct bfs
integrals None The one- and two-electron integrals to use
If not None, S,h,Ints
"""
maxiter = kwargs.get('maxiter',settings.OEPIters)
tol = kwargs.get('tol',settings.OEPTolerance)
ETemp = kwargs.get('ETemp',settings.DFTElectronTemperature)
bfs = getbasis(atoms,**kwargs)
# The basis set for the potential can be set different from
# that used for the wave function
pbfs = kwargs.get('pbfs')
if not pbfs: pbfs = bfs
npbf = len(pbfs)
S,h,Ints = getints(bfs,atoms,**kwargs)
nel = atoms.get_nel()
nclosed,nopen = atoms.get_closedopen()
nalpha,nbeta = nclosed+nopen,nclosed
Enuke = atoms.get_enuke()
# Form the OEP using Yang/Wu, PRL 89 143002 (2002)
nbf = len(bfs)
norb = nbf
ba = zeros(npbf,'d')
bb = zeros(npbf,'d')
# Form and store all of the three-center integrals
# we're going to need.
# These are <ibf|gbf|jbf> (where 'bf' indicates basis func,
# as opposed to MO)
# N^3 storage -- obviously you don't want to do this for
# very large systems
Gij = []
for g in xrange(npbf):
gmat = zeros((nbf,nbf),'d')
Gij.append(gmat)
gbf = pbfs[g]
for i in xrange(nbf):
ibf = bfs[i]
for j in xrange(i+1):
jbf = bfs[j]
gij = three_center(ibf,gbf,jbf)
gmat[i,j] = gij
gmat[j,i] = gij
# Compute the Fermi-Amaldi potential based on the LDA density.
# We're going to form this matrix from the Coulombic matrix that
# arises from the input orbitals. D0 and J0 refer to the density
# matrix and corresponding Coulomb matrix
D0 = mkdens(orbsa,0,nalpha)+mkdens(orbsb,0,nbeta)
J0 = getJ(Ints,D0)
Vfa = ((nel-1.)/nel)*J0
H0 = h + Vfa
eold = 0
for iter in xrange(maxiter):
Hoepa = get_Hoep(ba,H0,Gij)
Hoepb = get_Hoep(ba,H0,Gij)
orbea,orbsa = geigh(Hoepa,S)
orbeb,orbsb = geigh(Hoepb,S)
if ETemp:
efermia = get_efermi(2*nalpha,orbea,ETemp)
occsa = get_fermi_occs(efermia,orbea,ETemp)
Da = mkdens_occs(orbsa,occsa)
efermib = get_efermi(2*nbeta,orbeb,ETemp)
occsb = get_fermi_occs(efermib,orbeb,ETemp)
Db = mkdens_occs(orbsb,occsb)
entropy = 0.5*(get_entropy(occsa,ETemp)+get_entropy(occsb,ETemp))
else:
Da = mkdens(orbsa,0,nalpha)
Db = mkdens(orbsb,0,nbeta)
J = getJ(Ints,Da) + getJ(Ints,Db)
Ka = getK(Ints,Da)
Kb = getK(Ints,Db)
energy = (trace2(2*h+J-Ka,Da)+trace2(2*h+J-Kb,Db))/2\
+Enuke
if ETemp: energy += entropy
if abs(energy-eold) < tol:
break
else:
eold = energy
logging.debug("OEP AN Opt: %d %f" % (iter,energy))
# Do alpha and beta separately
# Alphas
dV_ao = J-Ka-Vfa
dV = matrixmultiply(orbsa,matrixmultiply(dV_ao,transpose(orbsa)))
X = zeros((nbf,nbf),'d')
c = zeros(nbf,'d')
for k in xrange(nbf):
Gk = matrixmultiply(orbsa,matrixmultiply(Gij[k],
transpose(orbsa)))
for i in xrange(nalpha):
for a in xrange(nalpha,norb):
c[k] += dV[i,a]*Gk[i,a]/(orbea[i]-orbea[a])
for l in xrange(nbf):
Gl = matrixmultiply(orbsa,matrixmultiply(Gij[l],
transpose(orbsa)))
for i in xrange(nalpha):
for a in xrange(nalpha,norb):
X[k,l] += Gk[i,a]*Gl[i,a]/(orbea[i]-orbea[a])
# This should actually be a pseudoinverse...
ba = solve(X,c)
# Betas
dV_ao = J-Kb-Vfa
dV = matrixmultiply(orbsb,matrixmultiply(dV_ao,transpose(orbsb)))
X = zeros((nbf,nbf),'d')
c = zeros(nbf,'d')
for k in xrange(nbf):
Gk = matrixmultiply(orbsb,matrixmultiply(Gij[k],
transpose(orbsb)))
for i in xrange(nbeta):
for a in xrange(nbeta,norb):
c[k] += dV[i,a]*Gk[i,a]/(orbeb[i]-orbeb[a])
for l in xrange(nbf):
Gl = matrixmultiply(orbsb,matrixmultiply(Gij[l],
transpose(orbsb)))
for i in xrange(nbeta):
for a in xrange(nbeta,norb):
X[k,l] += Gk[i,a]*Gl[i,a]/(orbeb[i]-orbeb[a])
# This should actually be a pseudoinverse...
bb = solve(X,c)
logger.info("Final OEP energy = %f" % energy)
return energy,(orbea,orbeb),(orbsa,orbsb)
def test_old():
from PyQuante.Molecule import Molecule
from PyQuante.Ints import getbasis,getints
from PyQuante.hartree_fock import rhf
logging.basicConfig(level=logging.DEBUG,format="%(message)s")
#mol = Molecule('HF',[('H',(0.,0.,0.)),('F',(0.,0.,0.898369))],
# units='Angstrom')
mol = Molecule('LiH',[(1,(0,0,1.5)),(3,(0,0,-1.5))],units = 'Bohr')
bfs = getbasis(mol)
S,h,Ints = getints(bfs,mol)
print "after integrals"
E_hf,orbe_hf,orbs_hf = rhf(mol,bfs=bfs,integrals=(S,h,Ints),DoAveraging=True)
print "RHF energy = ",E_hf
E_exx,orbe_exx,orbs_exx = exx(mol,orbs_hf,bfs=bfs,integrals=(S,h,Ints))
return
def test():
from PyQuante import Molecule, HFSolver, DFTSolver, UHFSolver
logging.basicConfig(level=logging.DEBUG,format="%(message)s")
mol = Molecule("He",[(2,(0,0,0))])
solver = HFSolver(mol)
solver.iterate()
print "HF energy = ",solver.energy
dft_solver = DFTSolver(mol)
dft_solver.iterate()
print "DFT energy = ",dft_solver.energy
oep = EXXSolver(solver)
# Testing 0 temp
oep.iterate()
# Testing finite temp
oep.iterate(etemp=40000)
return
def utest():
from PyQuante import Molecule, HFSolver, DFTSolver, UHFSolver
logging.basicConfig(level=logging.DEBUG,format="%(message)s")
mol = Molecule("He",[(2,(0,0,0))])
mol = Molecule("Li",[(3,(0,0,0))],multiplicity=2)
solver = UHFSolver(mol)
solver.iterate()
print "HF energy = ",solver.energy
dft_solver = DFTSolver(mol)
dft_solver.iterate()
print "DFT energy = ",dft_solver.energy
oep = UEXXSolver(solver)
# Testing 0 temp
oep.iterate()
# Testing finite temp
oep.iterate(etemp=10000)
return
if __name__ == '__main__':
test()
utest()
| berquist/PyQuante | PyQuante/OEP.py | Python | bsd-3-clause | 25,427 | 0.019664 |
import logging
import time
import os
# will change these to specific imports once code is more final
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5 import uic
BRUSH_WHITE = QBrush(QColor(255, 255, 255), Qt.SolidPattern)
BRUSH_GREEN = QBrush(QColor(0, 255, 0), Qt.SolidPattern)
BRUSH_BLACK = QBrush(QColor(0, 0, 0), Qt.SolidPattern)
BRUSH_DARK_PURPLE = QBrush(QColor(128, 0, 255), Qt.SolidPattern)
class DeviceNode:
__slots__ = ["_callback", "_name", "_data", "_type", "_brush", "q_name", "q_state", "sub_properties",
"sub_properties_appended", "q_time_added", "log"]
def __init__(self):
self._callback = None
self._name = ""
self._data = {}
self._type = ""
self._brush = BRUSH_BLACK
self.q_name = QStandardItem()
self.q_state = QStandardItem()
self.sub_properties = {}
self.sub_properties_appended = False
self.q_time_added = QStandardItem()
self.q_time_added.setData(time.perf_counter(), Qt.DisplayRole)
self.q_name.setDragEnabled(True)
self.q_state.setData("", Qt.DisplayRole)
self.log = logging.getLogger('Device')
def setName(self, name):
self._name = name
self.q_name.setData(str(self._name), Qt.DisplayRole)
self.log = logging.getLogger('Device {}'.format(self._name))
self.q_state.emitDataChanged()
def setData(self, data):
"""Set data of device."""
if data == self._data:
# do nothing if data did not change
return
if not isinstance(data, dict):
data = {}
if self._callback:
self._callback()
self._data = data
state_str = str(list(self._data.values())[0])
if len(self._data) > 1:
state_str = state_str + " {…}"
self.q_state.setData(state_str, Qt.DisplayRole)
for row in self._data:
if not self.sub_properties_appended:
q_property = QStandardItem()
q_value = QStandardItem()
self.sub_properties.update({row: [q_property, q_value]})
self.q_name.appendRow(self.sub_properties.get(row))
self.sub_properties.get(row)[0].setData(str(row), Qt.DisplayRole)
self.sub_properties.get(row)[1].setData(str(self._data.get(row)), Qt.DisplayRole)
self.sub_properties_appended = True
self.q_state.emitDataChanged()
self._brush = self._calculate_colored_brush()
def setType(self, type):
self._type = type
self._brush = self._calculate_colored_brush()
self.q_state.emitDataChanged()
def get_row(self):
return [self.q_name, self.q_state, self.q_time_added]
def data(self):
return self._data
def type(self):
return self._type
def get_colored_brush(self) -> QBrush:
"""Return colored brush for device."""
return self._brush
def _calculate_color_gamma_correction(self, color):
"""Perform gamma correction.
Feel free to fiddle with these constants until it feels right
With gamma = 0.5 and constant a = 18, the top 54 values are lost,
but the bottom 25% feels much more normal.
"""
gamma = 0.5
a = 18
corrected = []
for value in color:
if value < 0 or value > 255:
self.log.warning("Got value %s for brightness which outside the expected range", value)
value = 0
value = int(pow(value, gamma) * a)
if value > 255:
value = 255
corrected.append(value)
return corrected
def _calculate_colored_brush(self):
if self._type == 'light':
color = self.data()['color']
if color == [0, 0, 0]:
# shortcut for black
return BRUSH_BLACK
color = self._calculate_color_gamma_correction(color)
elif self._type == 'switch':
state = self.data()['state']
if state:
return BRUSH_GREEN
else:
return BRUSH_BLACK
elif self._type == 'diverter':
state = self.data()['active']
if state:
return BRUSH_DARK_PURPLE
else:
return BRUSH_BLACK
else:
# Get first parameter and draw as white if it evaluates True
state = bool(list(self.data().values())[0])
if state:
return BRUSH_WHITE
else:
return BRUSH_BLACK
return QBrush(QColor(*color), Qt.SolidPattern)
def set_change_callback(self, callback):
if self._callback:
# raise AssertionError("Can only have one callback")
old_callback = self._callback
self._callback = callback
return old_callback
else:
self._callback = callback
self.q_state.emitDataChanged()
class DeviceDelegate(QStyledItemDelegate):
def __init__(self):
self.size = None
super().__init__()
def paint(self, painter, view, index):
super().paint(painter, view, index)
color = None
state = None
balls = None
found = False
text = ''
# src_index = index.model().mapToSource(index)
# src_index_model = src_index.model()
# print(index.data())
# print(src_index_model.data())
data = []
try:
data = index.model().itemFromIndex(index).data()
# src_index = index.model().mapToSource(index)
# data = index.model().data(src_index)
except:
pass
num_circles = 1
# return
if index.column() == 0:
return
try:
if 'color' in data:
color = data['color']
found = True
except TypeError:
return
try:
if 'brightness' in data:
color = [data['brightness']]*3
found = True
except TypeError:
return
try:
if 'state' in data:
text = str(data['state'])
found = True
except TypeError:
return
try:
if 'complete' in data:
state = not data['complete']
found = True
except TypeError:
return
try:
if 'enabled' in data:
state = data['enabled']
found = True
except TypeError:
return
try:
if 'balls' in data:
balls = data['balls']
found = True
except TypeError:
return
try:
if 'balls_locked' in data:
balls = data['balls_locked']
found = True
except TypeError:
return
try:
if 'num_balls_requested' in data:
text += 'Requested: {} '.format(
data['num_balls_requested'])
found = True
except TypeError:
return
try:
if 'unexpected_balls' in data:
text += 'Unexpected: {} '.format(
data['unexpected_balls'])
found = True
except TypeError:
return
if not found:
return
text += " " + str(data)
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(QPen(QColor(100, 100, 100), 1, Qt.SolidLine))
if color:
painter.setBrush(QBrush(QColor(*color), Qt.SolidPattern))
elif state is True:
painter.setBrush(QBrush(QColor(0, 255, 0), Qt.SolidPattern))
elif state is False:
painter.setBrush(QBrush(QColor(255, 255, 255), Qt.SolidPattern))
elif isinstance(balls, int):
painter.setBrush(QBrush(QColor(0, 255, 0), Qt.SolidPattern))
num_circles = balls
x_offset = 0
for _ in range(num_circles):
painter.drawEllipse(
view.rect.x() + x_offset, view.rect.y(), 14, 14)
x_offset += 20
if text:
painter.drawText(view.rect.x() + x_offset, view.rect.y() + 12,
str(text))
self.size = QSize(len(text) * 10, 20)
painter.restore()
def sizeHint(self, QStyleOptionViewItem, QModelIndex):
if self.size:
return self.size
else:
# Calling super() here seems to result in a segfault on close sometimes.
# return super().sizeHint(QStyleOptionViewItem, QModelIndex)
return QSize(80, 20)
class DeviceWindow(QWidget):
__slots__ = ["mpfmn", "ui", "model", "log", "already_hidden", "added_index", "device_states",
"device_type_widgets", "_debug_enabled"]
def __init__(self, mpfmon):
self.mpfmon = mpfmon
super().__init__()
self.ui = None
self.model = None
self.draw_ui()
self.attach_model()
self.attach_signals()
self.log = logging.getLogger('Core')
self.already_hidden = False
self.added_index = 0
self.device_states = dict()
self.device_type_widgets = dict()
self._debug_enabled = self.log.isEnabledFor(logging.DEBUG)
def draw_ui(self):
# Load ui file from ./ui/
ui_path = os.path.join(os.path.dirname(__file__), "ui", "searchable_tree.ui")
self.ui = uic.loadUi(ui_path, self)
self.ui.setWindowTitle('Devices')
self.ui.move(self.mpfmon.local_settings.value('windows/devices/pos',
QPoint(200, 200)))
self.ui.resize(self.mpfmon.local_settings.value('windows/devices/size',
QSize(300, 600)))
# Disable option "Sort", select first item.
# TODO: Store and load selected sort index to local_settings
self.ui.sortComboBox.model().item(0).setEnabled(False)
self.ui.sortComboBox.setCurrentIndex(1)
self.ui.treeView.setAlternatingRowColors(True)
def attach_signals(self):
assert (self.ui is not None)
self.ui.treeView.expanded.connect(self.resize_columns_to_content)
self.ui.treeView.collapsed.connect(self.resize_columns_to_content)
self.ui.filterLineEdit.textChanged.connect(self.filter_text)
self.ui.sortComboBox.currentIndexChanged.connect(self.change_sort)
def attach_model(self):
assert (self.ui is not None)
self.treeview = self.ui.treeView
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(["Device", "Data"])
self.treeview.setDragDropMode(QAbstractItemView.DragOnly)
# self.treeview.setItemDelegateForColumn(1, DeviceDelegate())
# Resizing to contents causes huge performance losses. Only resize when rows expanded or collapsed.
# self.treeview.header().setSectionResizeMode(QHeaderView.ResizeToContents)
self.filtered_model = QSortFilterProxyModel(self)
self.filtered_model.setSourceModel(self.model)
self.filtered_model.setRecursiveFilteringEnabled(True)
self.filtered_model.setFilterCaseSensitivity(False)
self.treeview.setModel(self.filtered_model)
def resize_columns_to_content(self):
self.ui.treeView.resizeColumnToContents(0)
self.ui.treeView.resizeColumnToContents(1)
def process_device_update(self, name, state, changes, type):
del changes
if self._debug_enabled:
self.log.debug("Device Update: %s.%s: %s", type, name, state)
if type not in self.device_states:
self.device_states[type] = dict()
item = QStandardItem(type)
self.device_type_widgets[type] = item
self.model.appendRow([item, QStandardItem(), QStandardItem(str(time.perf_counter()))])
if name not in self.device_states[type]:
node = DeviceNode()
node.setName(name)
node.setData(state)
node.setType(type)
self.device_states[type][name] = node
self.device_type_widgets[type].appendRow(node.get_row())
self.mpfmon.pf.create_widget_from_config(node, type, name)
else:
self.device_states[type][name].setData(state)
self.ui.treeView.setColumnHidden(2, True)
def filter_text(self, string):
wc_string = "*" + str(string) + "*"
self.filtered_model.setFilterWildcard(wc_string)
self.ui.treeView.resizeColumnToContents(0)
self.ui.treeView.resizeColumnToContents(1)
def change_sort(self, index=1):
self.model.layoutAboutToBeChanged.emit()
self.filtered_model.beginResetModel()
# This is a bit sloppy and probably should be reworked.
if index == 1: # Received up
self.filtered_model.sort(2, Qt.AscendingOrder)
elif index == 2: # Received down
self.filtered_model.sort(2, Qt.DescendingOrder)
elif index == 3: # Name up
self.filtered_model.sort(0, Qt.AscendingOrder)
elif index == 4: # Name down
self.filtered_model.sort(0, Qt.DescendingOrder)
self.filtered_model.endResetModel()
self.model.layoutChanged.emit()
def closeEvent(self, event):
super().closeEvent(event)
self.mpfmon.write_local_settings()
event.accept()
self.mpfmon.check_if_quit()
| missionpinball/mpf-monitor | mpfmonitor/core/devices.py | Python | mit | 13,716 | 0.000948 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# ING UNI CT Telegram Bot
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
import logging
from utils import utility
from unidecode import unidecode
import json
#need load configuration from file
ROOMS_FILE='utils/rooms.json'
COURSES_FILE='utils/courses.json'
PROFESSORS_FILE='utils/professors.json'
CLASSROOMS_FILE='utils/classrooms.json'
EXAMS_FILE='utils/exams.json'
## Other files
TOKEN_FILE='token.conf'
LOG_FILE='ingbot.log'
##global variables
rooms={}
courses={}
professors={}
classrooms={}
exams=[]
# loading token from file
tokenconf = open(TOKEN_FILE, 'r').read()
tokenconf = tokenconf.replace("\n", "")
TOKEN = tokenconf
# Enable logging
logging.basicConfig(filename=LOG_FILE,format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
#define command handlers
def start_handler(bot, update):
newmsg = "Ing UniCT Telegram Bot\nLista Comandi:\n\t"\
"/orari <cld> <anno> Orario delle lezioni\n\t"\
"/esami <id cds> Elenco degli esami\n\t"\
"/corso <nome>\n\t/prof <cognome o nome> Informazioni sul professore\n\t"\
"/insegnamento <nome_insegnamento> Informazioni su un insegnamento\n\t"\
"/aula <numero> Indicazioni sull'ubicazione di un'aula\n\t"\
"/segreteria Informazioni sugli orari della segreteria studenti\n\t"\
"/cus Informazioni sul CUS"
newmsg += "\n\n\nATTENZIONE : Tutti i dati sono ricavati dal sito di Ingegneria,"\
" il bot non ha alcuna responsabilita' sulla corretteza di questi dati!!!\n"
developmode = '\n\n\n Il bot è in via di sviluppo se vuoi contribuire vai su:"\
" https://github.com/gabrik/ingunict-bot\nOppure contatta @Gakbri '
bot.sendMessage(update.message.chat_id, text=newmsg+developmode)
def help_handler(bot, update):
start(bot,update)
def schedule_handler(bot, update):
bot.sendMessage(update.message.chat_id, text='Orari temporaneamente non disponibili')
def professors_handler(bot, update):
msg = update.message.text
msg = msg.split(' ')
if len(msg)>=2:
professor_name = unidecode(" ".join(msg[1:]))
if len(professor_name)>3:
search_result = [professor for professor in professors if professor_name.upper() in professor['Nome'].upper()]
if len(search_result)>0:
bot.sendMessage(update.message.chat_id, text='Sono stati trovati %d professori '\
'con la tua ricerca' % len(search_result))
descr=""
for p in search_result:
descr += "Nome: %s\nQualifica: %s\nDipartimento: %s\n" % (p['Nome'], p['Qualifica'], p['Dipartimento'])
descr+= "Indirizzo: %s\nEmail: %s\nTelefono: %s\n" % (p['Indirizzo'], p['Email'], p['Telefono'])
descr+= "Sito: %s\nSSD: %s\n\n" % (p['Sito'], p['SSD'])
bot.sendMessage(update.message.chat_id,text= descr)
else:
bot.sendMessage(update.message.chat_id, text='Professore non trovato')
else:
bot.sendMessage(update.message.chat_id, text='Inserisci almeno 4 caratteri per la ricerca')
else:
bot.sendMessage(update.message.chat_id, text="Devi inserire il professore su cui ottenere informazioni!\n/prof <nome cognome>")
def classroom_handler(bot, update):
msg = update.message.text
msg = msg.split(' ')
if len(msg)==2:
insegnamento_name=unidecode(" ".join(msg[1:]))
if len(insegnamento_name)>3:
search_result=[insegnamento for insegnamento in classrooms if insegnamento_name.upper() in insegnamento['Nome'].upper()]
if len(search_result)>0:
bot.sendMessage(update.message.chat_id, text='Sono stati trovati %d insegnamenti con la tua ricerca' % len(search_result))
descr=""
for m in search_result:
doc=''.join([docente+'\n' for docente in m['Docenti']])
descr += "Nome: %s\nSemestre: %s\nCorso di Laurea: %s\n" % (m['Nome'], m['Semestre'], m['Corso di Laurea'])
descr+= "Anno: %s\nDocenti: %s\nSSD: %s\n" % (m['Anno'], doc, m['SSD'])
descr+= "CFU: %s\n\n" % (m['CFU'])
bot.sendMessage(update.message.chat_id, text=descr)
else:
bot.sendMessage(update.message.chat_id, text='Insegnamento non trovato')
else:
bot.sendMessage(update.message.chat_id, text='Inserisci almeno 4 caratteri per la ricerca')
else:
bot.sendMessage(update.message.chat_id, text="Devi inserire l'insegnamento su cui ottenere informazioni!\n/insegnamento <nome>")
def room_handler(bot, update):
msg = update.message.text
msg = msg.split(' ')
if len(msg)==2:
key = msg[1].upper().strip()
if key in rooms:
aula = rooms[key]
bot.sendMessage(update.message.chat_id, text='Aula %s , Edificio %s, Piano %s' % (key, aula['Edificio'], aula['Piano']))
else:
bot.sendMessage(update.message.chat_id, text='Aula non trovata')
else:
bot.sendMessage(update.message.chat_id, text="Devi inserire l'aula su cui ottenere informazioni!\n/aula <nome>")
def courses_handler(bot,update):
msg = update.message.text
msg = msg.split(' ')
if len(msg)==2:
nome_corso = unidecode(msg[1])
if len(nome_corso)>3:
search_result = [corso for corso in courses if nome_corso.upper() in corso['Denominazione'].upper()]
if len(search_result)>0:
bot.sendMessage(update.message.chat_id, text='Sono stati trovati %d corsi con la tua ricerca' % len(search_result))
descr=""
for corso in search_result:
descr+="Nome: %s\nID: %s\n" % (corso['Denominazione'], corso['ID'])
descr+="Codice: %s\nOrdinamento: %s\n Tipo: %s\n\n" % (corso['Codice'], corso['Ordinamento'], corso['Tipo'])
bot.sendMessage(update.message.chat_id, text=descr)
else:
bot.sendMessage(update.message.chat_id, text='Corso non trovato')
else:
bot.sendMessage(update.message.chat_id, text='Inserisci almeno 4 caratteri per la ricerca')
else:
bot.sendMessage(update.message.chat_id, text="Devi inserire il corso su cui ottenere informazioni!\n/corso <nome>")
def exams_handler(bot,update):
msg = update.message.text
msg = msg.split(' ')
if len(msg)==2:
cds_id = unidecode(msg[1])
search_result=[esame for esame in exams if cds_id==str(esame['CDS_ID'])]
if len(search_result)>0:
bot.sendMessage(update.message.chat_id, text='Sono stati trovati %d esami con la tua ricerca' % len(search_result))
for esame in search_result:
descr="Materia: %s\nData: %s\nOra: %s\n" % (esame['Insegnamento'], esame['Data'], esame['Ora'])
descr+='Aula: %s\n Scaglione: %s\nTipo: %s\nTipo Appello:%s\n\n' % (esame['Aula'], esame['Scaglione'], esame['Tipo Esame'], esame['Appello'])
bot.sendMessage(update.message.chat_id, text=descr)
else:
bot.sendMessage(update.message.chat_id, text="Corso non trovato verifica di aver inserito l'id corretto")
else:
bot.sendMessage(update.message.chat_id, text="Inserisci l'id del corso, lo puoi conoscere usando il comando corsi")
def secretary_handler(bot, update):
newmsg = "Carriera Studenti - Settore tecnico - scientifico\n\nVia S. Sofia, 64 - Edificio 11 C.U. 95135 Catania\n\nTel.:095-738 6104/2051"
newmsg+= "\n\n Orari\n\n"
newmsg+= "Lunedì 10.00 - 12.30\n"
newmsg= "Martedì 10.00 - 12.30 e 15.00 - 16.30\n"
newmsg+= "Mercoledì Chiusura\n"
newmsg+= "Giovedì 10.00 - 12.30 e 15.00 - 16.30\n"
newmsg+= "Venerdì 10.00 - 12.30\n"
newmsg+= "\n\n Telefonare solo nelle fasce orarie di apertura"
newmsg+= "\n\n Mail: settore.tecnicoscientifico@unict.it"
newmsg+= "\n\n Per ulteriori infomazioni : http://www.unict.it/content/coordinamento-settori-carriere-studenti"
bot.sendMessage(update.message.chat_id, text=newmsg)
def cus_handler(bot, update):
newmsg="CUS CATANIA:\n\nViale A. Doria n° 6 - 95125 Catania\n\ntel. 095336327- fax 095336478\n\n"\
"CUS Catania - info@cuscatania.it\n\n"\
"Segreteria studenti:\ntel. 095/336327 (int. 0) - segreteriastudenti@cuscatania.it "
bot.sendMessage(update.message.chat_id, text=newmsg)
def error_handler(bot, update, error):
logger.warn('Update "%s" caused error "%s"' % (update, error))
def main():
# loading data from files
logger.info('[LOADING] rooms from "%s"' % ROOMS_FILE)
global rooms
rooms = utility.load_rooms(ROOMS_FILE)
logger.info('[ DONE ] loading rooms')
logger.info('[LOADING] courses from "%s"' % COURSES_FILE)
global courses
courses = utility.load_courses(COURSES_FILE)
logger.info('[ DONE ] loading courses')
logger.info('[LOADING] professors from "%s"' % PROFESSORS_FILE)
global professors
professors = utility.load_professors(PROFESSORS_FILE)
logger.info('[ DONE ] loading professors')
logger.info('[LOADING] classrooms from "%s"' % CLASSROOMS_FILE)
global classrooms
classrooms = utility.load_classrooms(CLASSROOMS_FILE)
logger.info('[ DONE ] loading classrooms')
logger.info('[LOADING] exams from "%s"' % EXAMS_FILE)
global exams
exams = utility.load_exams(EXAMS_FILE)
logger.info('[ DONE ] loading exams')
#setting up bot
updater = Updater(TOKEN)
dp = updater.dispatcher
#setting handlers
dp.add_handler(CommandHandler("start", start_handler))
dp.add_handler(CommandHandler("help", start_handler))
dp.add_handler(CommandHandler("prof", professors_handler))
dp.add_handler(CommandHandler("corso", courses_handler))
dp.add_handler(CommandHandler("esami", exams_handler))
dp.add_handler(CommandHandler("orari", schedule_handler))
dp.add_handler(CommandHandler("insegnamento", classroom_handler))
dp.add_handler(CommandHandler("aula", room_handler))
dp.add_handler(CommandHandler("segreteria", secretary_handler))
dp.add_handler(CommandHandler("cus", cus_handler))
dp.add_error_handler(error_handler)
updater.start_polling()
logger.info('[ INFO ] Bot started!')
updater.idle()
if __name__ == '__main__':
main()
| gabrik/ingunict-bot | ingbot.py | Python | apache-2.0 | 9,550 | 0.030389 |
from setuptools import setup, find_packages
with open('README.rst') as f:
description = f.read()
setup(
name='knitty-gritty',
version='0.0.2',
description='A tool for managing knitting machine patterns',
long_description=description,
url='https://github.com/mhallin/knitty-gritty',
author='Magnus Hallin',
author_email='mhallin@gmail.com',
license='BSD',
packages=find_packages(),
install_requires=[
'click>=2.4,<2.5',
'Pillow>=2.5,<2.6',
'pyserial>=2.7,<2.8',
],
extras_require={
'dev': [
'flake8>=2.2,<2.3',
'mccabe>=0.2,<0.3',
'pep8>=1.5,<1.6',
'pip-tools>=0.3,<0.4',
'pyflakes>=0.8.1,<0.9',
'wheel>=0.24,<0.25',
],
},
entry_points={
'console_scripts': [
'knitty-gritty = knittygritty.main:cli'
],
},
)
| mhallin/knitty-gritty | setup.py | Python | bsd-3-clause | 918 | 0 |
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
__all__ = [
"__title__", "__summary__", "__uri__", "__version__", "__author__",
"__email__", "__license__", "__copyright__",
]
__title__ = "stockpile"
__summary__ = "Generic file storage abstraction"
__uri__ = "https://github.com/dstufft/stockpile/"
__version__ = "0.1"
__author__ = "Donald Stufft"
__email__ = "donald.stufft@gmail.com"
__license__ = "Simplified BSD"
__copyright__ = "Copyright 2012 Donald Stufft"
| pombredanne/stockpile | stockpile/__about__.py | Python | bsd-2-clause | 539 | 0 |
'''
Integration Test for scheduler reboot VM in HA mode.
@author: Quarkonics
'''
import zstackwoodpecker.test_util as test_util
import zstackwoodpecker.test_state as test_state
import zstackwoodpecker.test_lib as test_lib
import zstackwoodpecker.operations.resource_operations as res_ops
import zstackwoodpecker.zstack_test.zstack_test_vm as test_vm_header
import zstackwoodpecker.operations.vm_operations as vm_ops
import zstackwoodpecker.operations.scheduler_operations as schd_ops
import test_stub
import time
import os
vm = None
node1_ip = None
node2_ip = None
def test():
global vm
global node1_ip
vm = test_stub.create_basic_vm()
vm.check()
start_date = int(time.time())
schd = vm_ops.reboot_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_reboot_vm_scheduler', start_date+60, 30)
node1_ip = os.environ.get('node1Ip')
node2_ip = os.environ.get('node2Ip')
test_util.test_logger("shutdown node: %s" % (node1_ip))
cmd = "init 0"
host_username = os.environ.get('nodeUserName')
host_password = os.environ.get('nodePassword')
rsp = test_lib.lib_execute_ssh_cmd(node1_ip, host_username, host_password, cmd, 180)
test_util.test_logger("wait for 2 minutes to see if http api still works well")
time.sleep(180)
test_stub.exercise_connection(600)
time.sleep(180)
scheduler_execution_count = 0
for i in range(0, 30):
for j in range(0, 6):
if test_lib.lib_find_in_remote_management_server_log(node1_ip, host_username, host_password, start_date+60+30*i+j, '[msg received]: {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid):
scheduler_execution_count += 1
if test_lib.lib_find_in_remote_management_server_log(node2_ip, host_username, host_password, start_date+60+30*i+j, '[msg received]: {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid):
scheduler_execution_count -= 1
if abs(scheduler_execution_count) < 5:
test_util.test_fail('VM reboot scheduler is expected to executed for more than 5 times, while it only execute %s times' % (scheduler_execution_count))
schd_ops.delete_scheduler(schd.uuid)
vm.destroy()
test_util.test_logger("recover node: %s" % (node1_ip))
os.system('bash -ex %s %s' % (os.environ.get('nodeRecoverScript'), node1_ip))
time.sleep(180)
test_stub.exercise_connection(600)
test_util.test_pass('Scheduler Test Success')
#Will be called only if exception happens in test().
def error_cleanup():
global vm
global node1_ip
if vm:
try:
vm.destroy()
except:
pass
test_util.test_logger("recover node: %s" % (node1_ip))
os.system('bash -ex %s %s' % (os.environ.get('nodeRecoverScript'), node1_ip))
time.sleep(180)
test_stub.exercise_connection(600)
| zstackio/zstack-woodpecker | integrationtest/vm/ha/test_one_node_shutdown_with_scheduler.py | Python | apache-2.0 | 2,920 | 0.004452 |
from datetime import date, datetime
from dateutil import relativedelta
import json
import time
from openerp.osv import fields, osv
from openerp.tools import float_compare
from openerp.tools.translate import _
from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT, DEFAULT_SERVER_DATE_FORMAT
from openerp import SUPERUSER_ID, api
import openerp.addons.decimal_precision as dp
from openerp.addons.procurement import procurement
import logging
_logger = logging.getLogger(__name__)
class stock_internal_transfer(osv.osv):
_name = 'stock.internal.transfer'
_inherit = ['mail.thread', 'ir.needaction_mixin']
# def create(self, cr, uid, vals, context=None):
# data = super(stock_internal_transfer, self).create(cr, uid, vals, context=context)
# if self.pool.get('res.users').browse(cr,uid,uid).company_id.transit_location_id:
# raise osv.except_osv(_('Error!'), _('Please setup your stock transit location in Setting - Warehouse'))
# return data
def action_cancel(self, cr, uid, ids, context):
self.write(cr, uid, ids, {
'state' : 'cancel'
})
return True
def action_draft(self, cr, uid, ids, context):
self.write(cr, uid, ids, {
'state' : 'draft'
})
return True
def action_send(self, cr, uid, ids, context):
self.write(cr, uid, ids, {
'state' : 'send'
})
return True
def action_receive(self, cr, uid, ids, context):
self.write(cr, uid, ids, {
'state' : 'done'
})
return True
def do_enter_wizard(self, cr, uid, ids, context):
if not context:
context = {}
context.update({
'active_model': self._name,
'active_ids': ids,
'active_id': len(ids) and ids[0] or False
})
created_id = self.pool['wizard.stock.internal.transfer'].create(cr, uid, {'transfer_id': len(ids) and ids[0] or False}, context)
return self.pool['wizard.stock.internal.transfer'].wizard_view(cr, uid, created_id, context)
_columns = {
'name' : fields.char('Reference', track_visibility='onchange'),
'date' : fields.datetime('Date', track_visibility='onchange'),
'source_warehouse_id' : fields.many2one('stock.warehouse', 'Source Warehouse', track_visibility='onchange'),
'dest_warehouse_id' : fields.many2one('stock.warehouse', 'Destination Warehouse', track_visibility='onchange'),
'state' : fields.selection([('cancel', 'Cancel'), ('draft', 'Draft'), ('send', 'Send'), ('done', 'Done')], 'Status', track_visibility='onchange'),
'line_ids' : fields.one2many('stock.internal.transfer.line', 'transfer_id', 'Stock Internal Transfer Line'),
'picking_ids' : fields.one2many('stock.picking', 'transfer_id', 'Picking'),
'backorder_id' : fields.many2one('stock.internal.transfer', 'Backorder'),
}
_defaults = {
'name': lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'stock.internal.transfer'),
'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),
'state' : lambda *a: 'draft',
}
class stock_internal_transfer_line(osv.osv):
_name = 'stock.internal.transfer.line'
_inherit = ['mail.thread', 'ir.needaction_mixin']
def product_id_change(self, cr, uid, ids, product_id, context=None):
""" Finds UoM of changed product.
@param product_id: Id of changed product.
@return: Dictionary of values.
"""
result = {}
if not product_id:
return {'value': {
'product_uom_id': False,
}}
product = self.pool.get('product.product').browse(cr, uid, product_id, context=context)
product_uom_id = product.uom_id and product.uom_id.id or False
result['value'] = {'product_uom_id': product_uom_id}
return result
_columns = {
'name' : fields.char('Reference', track_visibility='onchange'),
'product_id' : fields.many2one('product.product', 'Product', track_visibility='onchange'),
'product_qty' : fields.float('Quantity', track_visibility='onchange'),
'product_uom_id' : fields.many2one('product.uom', 'Unit of Measure', track_visibility='onchange'),
'state' : fields.selection([('cancel', 'Cancel'), ('draft', 'Draft'), ('send', 'Send'), ('done', 'Done')], 'Status', track_visibility='onchange'),
'transfer_id' : fields.many2one('stock.internal.transfer', 'Transfer', track_visibility='onchange'),
}
_defaults = {
'state' : lambda *a: 'draft',
'product_qty' : lambda *a: 1,
} | dendyyangky/sgeede_b2b | sgeede_internal_transfer/stock_internal_transfer.py | Python | unlicense | 4,237 | 0.029974 |
# -*- coding: utf-8 -*-
#
# Copyright (C) 2009-2015 Ben Kurtovic <ben.kurtovic@gmail.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
from earwigbot import exceptions
from earwigbot import wiki
__all__ = ["Task"]
class Task:
"""
**EarwigBot: Base Bot Task**
This package provides built-in wiki bot "tasks" EarwigBot runs. Additional
tasks can be installed as plugins in the bot's working directory.
This class (import with ``from earwigbot.tasks import Task``) can be
subclassed to create custom bot tasks.
To run a task, use :py:meth:`bot.tasks.start(name, **kwargs)
<earwigbot.managers.TaskManager.start>`. ``**kwargs`` get passed to the
Task's :meth:`run` method.
"""
name = None
number = 0
def __init__(self, bot):
"""Constructor for new tasks.
This is called once immediately after the task class is loaded by
the task manager (in :py:meth:`tasks.load()
<earwigbot.managers._ResourceManager.load>`). Don't override this
directly; if you do, remember to place ``super().__init()`` first.
Use :py:meth:`setup` for typical task-init/setup needs.
"""
self.bot = bot
self.config = bot.config
self.logger = bot.tasks.logger.getChild(self.name)
number = self.config.tasks.get(self.name, {}).get("number")
if number is not None:
self.number = number
self.setup()
def __repr__(self):
"""Return the canonical string representation of the Task."""
res = "Task(name={0!r}, number={1!r}, bot={2!r})"
return res.format(self.name, self.number, self.bot)
def __str__(self):
"""Return a nice string representation of the Task."""
res = "<Task {0} ({1}) of {2}>"
return res.format(self.name, self.number, self.bot)
def setup(self):
"""Hook called immediately after the task is loaded.
Does nothing by default; feel free to override.
"""
pass
def run(self, **kwargs):
"""Main entry point to run a given task.
This is called directly by :py:meth:`tasks.start()
<earwigbot.managers.TaskManager.start>` and is the main way to make a
task do stuff. *kwargs* will be any keyword arguments passed to
:py:meth:`~earwigbot.managers.TaskManager.start`, which are entirely
optional.
"""
pass
def unload(self):
"""Hook called immediately before the task is unloaded.
Does nothing by default; feel free to override.
"""
pass
def make_summary(self, comment):
"""Make an edit summary by filling in variables in a config value.
:py:attr:`config.wiki["summary"] <earwigbot.config.BotConfig.wiki>` is
used, where ``$2`` is replaced by the main summary body, given by the
*comment* argument, and ``$1`` is replaced by the task number.
If the config value is not found, we'll just return *comment* as-is.
"""
try:
summary = self.bot.config.wiki["summary"]
except KeyError:
return comment
return summary.replace("$1", str(self.number)).replace("$2", comment)
def shutoff_enabled(self, site=None):
"""Return whether on-wiki shutoff is enabled for this task.
We check a certain page for certain content. This is determined by
our config file: :py:attr:`config.wiki["shutoff"]["page"]
<earwigbot.config.BotConfig.wiki>` is used as the title, with any
embedded ``$1`` replaced by our username and ``$2`` replaced by the
task number; and :py:attr:`config.wiki["shutoff"]["disabled"]
<earwigbot.config.BotConfig.wiki>` is used as the content.
If the page has that exact content or the page does not exist, then
shutoff is "disabled", meaning the bot is supposed to run normally, and
we return ``False``. If the page's content is something other than
what we expect, shutoff is enabled, and we return ``True``.
If a site is not provided, we'll try to use :py:attr:`self.site <site>`
if it's set. Otherwise, we'll use our default site.
"""
if not site:
if hasattr(self, "site"):
site = getattr(self, "site")
else:
site = self.bot.wiki.get_site()
try:
cfg = self.config.wiki["shutoff"]
except KeyError:
return False
title = cfg.get("page", "User:$1/Shutoff/Task $2")
username = site.get_user().name
title = title.replace("$1", username).replace("$2", str(self.number))
page = site.get_page(title)
try:
content = page.get()
except exceptions.PageNotFoundError:
return False
if content == cfg.get("disabled", "run"):
return False
self.logger.warn("Emergency task shutoff has been enabled!")
return True
| earwig/earwigbot | earwigbot/tasks/__init__.py | Python | mit | 5,993 | 0.000167 |
from ... import Something
from . import data
try:
from ... import Lala
except ImportError:
pass | arju88nair/projectCulminate | venv/lib/python3.5/site-packages/pylint/test/regrtest_data/beyond_top/__init__.py | Python | apache-2.0 | 108 | 0.009259 |
# pylint:disable-msg=R0201
"""docstring"""
__revision__ = ''
class Interface:
"""base class for interfaces"""
class IMachin(Interface):
"""docstring"""
def truc(self):
"""docstring"""
def troc(self, argument):
"""docstring"""
class Correct1:
"""docstring"""
__implements__ = IMachin
def __init__(self):
pass
def truc(self):
"""docstring"""
pass
def troc(self, argument):
"""docstring"""
pass
class Correct2:
"""docstring"""
__implements__ = (IMachin,)
def __init__(self):
pass
def truc(self):
"""docstring"""
pass
def troc(self, argument):
"""docstring"""
print argument
class MissingMethod:
"""docstring"""
__implements__ = IMachin,
def __init__(self):
pass
def troc(self, argument):
"""docstring"""
print argument
def other(self):
"""docstring"""
class BadArgument:
"""docstring"""
__implements__ = (IMachin,)
def __init__(self):
pass
def truc(self):
"""docstring"""
pass
def troc(self):
"""docstring"""
pass
class InterfaceCantBeFound:
"""docstring"""
__implements__ = undefined
def __init__(self):
"""only to make pylint happier"""
def please(self):
"""public method 1/2"""
def besilent(self):
"""public method 2/2"""
class InterfaceCanNowBeFound:
"""docstring"""
__implements__ = BadArgument.__implements__ + Correct2.__implements__
def __init__(self):
"""only to make pylint happier"""
def please(self):
"""public method 1/2"""
def besilent(self):
"""public method 2/2"""
| dbbhattacharya/kitsune | vendor/packages/pylint/test/input/func_interfaces.py | Python | bsd-3-clause | 1,802 | 0.010544 |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.6 on 2017-11-15 14:54
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('backend', '0008_auto_20171115_1443'),
]
operations = [
migrations.AddField(
model_name='userprofile',
name='level',
field=models.PositiveIntegerField(default=1),
),
]
| Petrole/MaturePyRobots | WebPyRobot/backend/migrations/0009_userprofile_level.py | Python | gpl-3.0 | 460 | 0 |
from office import Office
from bank import Bank
bank = Bank("Open Bank")
office = Office("Timisoara", bank)
office.open()
| vtemian/university_projects | practic_stage/hmw7/main.py | Python | apache-2.0 | 125 | 0 |
#
# common.py
#
# Copyright (C) 2009 Justin Noah <justinnoah@gmail.com>
#
# Basic plugin template created by:
# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
#
# Deluge is free software.
#
# You may 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.
#
# deluge 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 deluge. If not, write to:
# The Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor
# Boston, MA 02110-1301, USA.
#
# In addition, as a special exception, the copyright holders give
# permission to link the code of portions of this program with the OpenSSL
# library.
# You must obey the GNU General Public License in all respects for all of
# the code used other than OpenSSL. If you modify file(s) with this
# exception, you may extend this exception to your version of the file(s),
# but you are not obligated to do so. If you do not wish to do so, delete
# this exception statement from your version. If you delete this exception
# statement from all source files in the program, then also delete it here.
#
def get_resource(filename):
import pkg_resources, os
return pkg_resources.resource_filename("autobot", os.path.join("data", filename))
| justinnoah/autobot | autobot/common.py | Python | apache-2.0 | 1,761 | 0.001136 |
# coding: utf-8
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
"""
===================
dMRI: Preprocessing
===================
Introduction
============
This script, dmri_preprocessing.py, demonstrates how to prepare dMRI data
for tractography and connectivity analysis with nipype.
We perform this analysis using the FSL course data, which can be acquired from
here: http://www.fmrib.ox.ac.uk/fslcourse/fsl_course_data2.tar.gz
Can be executed in command line using ``python dmri_preprocessing.py``
Import necessary modules from nipype.
"""
import os # system functions
import nipype.interfaces.io as nio # Data i/o
import nipype.interfaces.utility as niu # utility
import nipype.algorithms.misc as misc
import nipype.pipeline.engine as pe # pypeline engine
from nipype.interfaces import fsl
from nipype.interfaces import ants
"""
Load specific nipype's workflows for preprocessing of dMRI data:
:class:`nipype.workflows.dmri.preprocess.epi.all_peb_pipeline`,
as data include a *b0* volume with reverse encoding direction
(*P>>>A*, or *y*), in contrast with the general acquisition encoding
that is *A>>>P* or *-y* (in RAS systems).
"""
from nipype.workflows.dmri.fsl.artifacts import all_fsl_pipeline, remove_bias
"""
Map field names into individual subject runs
"""
info = dict(dwi=[['subject_id', 'dwidata']],
bvecs=[['subject_id', 'bvecs']],
bvals=[['subject_id', 'bvals']],
dwi_rev=[['subject_id', 'nodif_PA']])
infosource = pe.Node(interface=niu.IdentityInterface(fields=['subject_id']),
name="infosource")
# Set the subject 1 identifier in subject_list,
# we choose the preproc dataset as it contains uncorrected files.
subject_list = ['subj1_preproc']
"""Here we set up iteration over all the subjects. The following line
is a particular example of the flexibility of the system. The
``datasource`` attribute ``iterables`` tells the pipeline engine that
it should repeat the analysis on each of the items in the
``subject_list``. In the current example, the entire first level
preprocessing and estimation will be repeated for each subject
contained in subject_list.
"""
infosource.iterables = ('subject_id', subject_list)
"""
Now we create a :class:`nipype.interfaces.io.DataGrabber` object and
fill in the information from above about the layout of our data. The
:class:`~nipype.pipeline.engine.Node` module wraps the interface object
and provides additional housekeeping and pipeline specific
functionality.
"""
datasource = pe.Node(nio.DataGrabber(infields=['subject_id'],
outfields=list(info.keys())), name='datasource')
datasource.inputs.template = "%s/%s"
# This needs to point to the fdt folder you can find after extracting
# http://www.fmrib.ox.ac.uk/fslcourse/fsl_course_data2.tar.gz
datasource.inputs.base_directory = os.path.abspath('fdt1')
datasource.inputs.field_template = dict(dwi='%s/%s.nii.gz',
dwi_rev='%s/%s.nii.gz')
datasource.inputs.template_args = info
datasource.inputs.sort_filelist = True
"""
An inputnode is used to pass the data obtained by the data grabber to the
actual processing functions
"""
inputnode = pe.Node(niu.IdentityInterface(fields=["dwi", "bvecs", "bvals",
"dwi_rev"]), name="inputnode")
"""
Setup for dMRI preprocessing
============================
In this section we initialize the appropriate workflow for preprocessing of
diffusion images.
Artifacts correction
--------------------
We will use the combination of ``topup`` and ``eddy`` as suggested by FSL.
In order to configure the susceptibility distortion correction (SDC), we first
write the specific parameters of our echo-planar imaging (EPI) images.
Particularly, we look into the ``acqparams.txt`` file of the selected subject
to gather the encoding direction, acceleration factor (in parallel sequences
it is > 1), and readout time or echospacing.
"""
epi_AP = {'echospacing': 66.5e-3, 'enc_dir': 'y-'}
epi_PA = {'echospacing': 66.5e-3, 'enc_dir': 'y'}
prep = all_fsl_pipeline(epi_params=epi_AP, altepi_params=epi_PA)
"""
Bias field correction
---------------------
Finally, we set up a node to correct for a single multiplicative bias field
from computed on the *b0* image, as suggested in [Jeurissen2014]_.
"""
bias = remove_bias()
"""
Connect nodes in workflow
=========================
We create a higher level workflow to connect the nodes. Please excuse the
author for writing the arguments of the ``connect`` function in a not-standard
style with readability aims.
"""
wf = pe.Workflow(name="dMRI_Preprocessing")
wf.base_dir = os.path.abspath('preprocessing_dmri_tutorial')
wf.connect([
(infosource, datasource, [('subject_id', 'subject_id')]),
(datasource, prep, [('dwi', 'inputnode.in_file'),
('dwi_rev', 'inputnode.alt_file'),
('bvals', 'inputnode.in_bval'),
('bvecs', 'inputnode.in_bvec')]),
(prep, bias, [('outputnode.out_file', 'inputnode.in_file'),
('outputnode.out_mask', 'inputnode.in_mask')]),
(datasource, bias, [('bvals', 'inputnode.in_bval')])
])
"""
Run the workflow as command line executable
"""
if __name__ == '__main__':
wf.run()
wf.write_graph()
| BrainIntensive/OnlineBrainIntensive | resources/nipype/nipype/examples/dmri_preprocessing.py | Python | mit | 5,464 | 0.000549 |
# Copyright (C) 2019 The Electrum developers
# Distributed under the MIT software license, see the accompanying
# file LICENCE or http://www.opensource.org/licenses/mit-license.php
import asyncio
import base64
from distutils.version import LooseVersion
from PyQt5.QtCore import Qt, QThread, pyqtSignal
from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QLabel, QProgressBar,
QHBoxLayout, QPushButton, QDialog)
from electrum_mona import version
from electrum_mona import constants
from electrum_mona import ecc
from electrum_mona.i18n import _
from electrum_mona.util import make_aiohttp_session
from electrum_mona.logging import Logger
from electrum_mona.network import Network
class UpdateCheck(QDialog, Logger):
url = "https://electrum-mona.org/version"
download_url = "https://electrum-mona.org"
VERSION_ANNOUNCEMENT_SIGNING_KEYS = (
"MUJ1nBxpAzdGdNhTN1x3MCtyeBa4DbdqpK",
)
def __init__(self, *, latest_version=None):
QDialog.__init__(self)
self.setWindowTitle('Electrum - ' + _('Update Check'))
self.content = QVBoxLayout()
self.content.setContentsMargins(*[10]*4)
self.heading_label = QLabel()
self.content.addWidget(self.heading_label)
self.detail_label = QLabel()
self.detail_label.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
self.detail_label.setOpenExternalLinks(True)
self.content.addWidget(self.detail_label)
self.pb = QProgressBar()
self.pb.setMaximum(0)
self.pb.setMinimum(0)
self.content.addWidget(self.pb)
versions = QHBoxLayout()
versions.addWidget(QLabel(_("Current version: {}".format(version.ELECTRUM_VERSION))))
self.latest_version_label = QLabel(_("Latest version: {}".format(" ")))
versions.addWidget(self.latest_version_label)
self.content.addLayout(versions)
self.update_view(latest_version)
self.update_check_thread = UpdateCheckThread()
self.update_check_thread.checked.connect(self.on_version_retrieved)
self.update_check_thread.failed.connect(self.on_retrieval_failed)
self.update_check_thread.start()
close_button = QPushButton(_("Close"))
close_button.clicked.connect(self.close)
self.content.addWidget(close_button)
self.setLayout(self.content)
self.show()
def on_version_retrieved(self, version):
self.update_view(version)
def on_retrieval_failed(self):
self.heading_label.setText('<h2>' + _("Update check failed") + '</h2>')
self.detail_label.setText(_("Sorry, but we were unable to check for updates. Please try again later."))
self.pb.hide()
@staticmethod
def is_newer(latest_version):
return latest_version > LooseVersion(version.ELECTRUM_VERSION)
def update_view(self, latest_version=None):
if latest_version:
self.pb.hide()
self.latest_version_label.setText(_("Latest version: {}".format(latest_version)))
if self.is_newer(latest_version):
self.heading_label.setText('<h2>' + _("There is a new update available") + '</h2>')
url = "<a href='{u}'>{u}</a>".format(u=UpdateCheck.download_url)
self.detail_label.setText(_("You can download the new version from {}.").format(url))
else:
self.heading_label.setText('<h2>' + _("Already up to date") + '</h2>')
self.detail_label.setText(_("You are already on the latest version of Electrum."))
else:
self.heading_label.setText('<h2>' + _("Checking for updates...") + '</h2>')
self.detail_label.setText(_("Please wait while Electrum checks for available updates."))
class UpdateCheckThread(QThread, Logger):
checked = pyqtSignal(object)
failed = pyqtSignal()
def __init__(self):
QThread.__init__(self)
Logger.__init__(self)
self.network = Network.get_instance()
async def get_update_info(self):
# note: Use long timeout here as it is not critical that we get a response fast,
# and it's bad not to get an update notification just because we did not wait enough.
async with make_aiohttp_session(proxy=self.network.proxy, timeout=120) as session:
async with session.get(UpdateCheck.url) as result:
signed_version_dict = await result.json(content_type=None)
# example signed_version_dict:
# {
# "version": "3.9.9",
# "signatures": {
# "MRkEwoPcvSPaC5WNtQMa7NGPy2tBKbp3Bm": "H84UFTdaBswxTrNty0gLlWiQEQhJA2Se5xVdhR9zFirKYg966IXEkC7km6phIJq+2CT3KwvKuj8YKaSCy1fErwg="
# }
# }
version_num = signed_version_dict['version']
sigs = signed_version_dict['signatures']
for address, sig in sigs.items():
if address not in UpdateCheck.VERSION_ANNOUNCEMENT_SIGNING_KEYS:
continue
sig = base64.b64decode(sig)
msg = version_num.encode('utf-8')
if ecc.verify_message_with_address(address=address, sig65=sig, message=msg,
net=constants.BitcoinMainnet):
self.logger.info(f"valid sig for version announcement '{version_num}' from address '{address}'")
break
else:
raise Exception('no valid signature for version announcement')
return LooseVersion(version_num.strip())
def run(self):
if not self.network:
self.failed.emit()
return
try:
update_info = asyncio.run_coroutine_threadsafe(self.get_update_info(), self.network.asyncio_loop).result()
except Exception as e:
self.logger.info(f"got exception: '{repr(e)}'")
self.failed.emit()
else:
self.checked.emit(update_info)
| wakiyamap/electrum-mona | electrum_mona/gui/qt/update_checker.py | Python | mit | 6,116 | 0.00327 |
"""Common code for Withings."""
import asyncio
from dataclasses import dataclass
import datetime
from datetime import timedelta
from enum import Enum, IntEnum
import logging
import re
from typing import Any, Callable, Dict, List, Optional, Tuple, Union
from aiohttp.web import Response
import requests
from withings_api import AbstractWithingsApi
from withings_api.common import (
AuthFailedException,
GetSleepSummaryField,
MeasureGroupAttribs,
MeasureType,
MeasureTypes,
NotifyAppli,
SleepGetSummaryResponse,
UnauthorizedException,
query_measure_groups,
)
from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
from homeassistant.components.http import HomeAssistantView
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
CONF_WEBHOOK_ID,
HTTP_UNAUTHORIZED,
MASS_KILOGRAMS,
PERCENTAGE,
SPEED_METERS_PER_SECOND,
TIME_SECONDS,
)
from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import config_entry_oauth2_flow
from homeassistant.helpers.config_entry_oauth2_flow import (
AUTH_CALLBACK_PATH,
AbstractOAuth2Implementation,
LocalOAuth2Implementation,
OAuth2Session,
)
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.entity_registry import EntityRegistry
from homeassistant.helpers.network import get_url
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
from homeassistant.util import dt
from . import const
from .const import Measurement
_LOGGER = logging.getLogger(const.LOG_NAMESPACE)
NOT_AUTHENTICATED_ERROR = re.compile(
f"^{HTTP_UNAUTHORIZED},.*",
re.IGNORECASE,
)
DATA_UPDATED_SIGNAL = "withings_entity_state_updated"
MeasurementData = Dict[Measurement, Any]
class NotAuthenticatedError(HomeAssistantError):
"""Raise when not authenticated with the service."""
class ServiceError(HomeAssistantError):
"""Raise when the service has an error."""
class UpdateType(Enum):
"""Data update type."""
POLL = "poll"
WEBHOOK = "webhook"
@dataclass
class WithingsAttribute:
"""Immutable class for describing withings sensor data."""
measurement: Measurement
measute_type: Enum
friendly_name: str
unit_of_measurement: str
icon: Optional[str]
platform: str
enabled_by_default: bool
update_type: UpdateType
@dataclass
class WithingsData:
"""Represents value and meta-data from the withings service."""
attribute: WithingsAttribute
value: Any
@dataclass
class WebhookConfig:
"""Config for a webhook."""
id: str
url: str
enabled: bool
@dataclass
class StateData:
"""State data held by data manager for retrieval by entities."""
unique_id: str
state: Any
WITHINGS_ATTRIBUTES = [
WithingsAttribute(
Measurement.WEIGHT_KG,
MeasureType.WEIGHT,
"Weight",
MASS_KILOGRAMS,
"mdi:weight-kilogram",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.FAT_MASS_KG,
MeasureType.FAT_MASS_WEIGHT,
"Fat Mass",
MASS_KILOGRAMS,
"mdi:weight-kilogram",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.FAT_FREE_MASS_KG,
MeasureType.FAT_FREE_MASS,
"Fat Free Mass",
MASS_KILOGRAMS,
"mdi:weight-kilogram",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.MUSCLE_MASS_KG,
MeasureType.MUSCLE_MASS,
"Muscle Mass",
MASS_KILOGRAMS,
"mdi:weight-kilogram",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.BONE_MASS_KG,
MeasureType.BONE_MASS,
"Bone Mass",
MASS_KILOGRAMS,
"mdi:weight-kilogram",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.HEIGHT_M,
MeasureType.HEIGHT,
"Height",
const.UOM_LENGTH_M,
"mdi:ruler",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.TEMP_C,
MeasureType.TEMPERATURE,
"Temperature",
const.UOM_TEMP_C,
"mdi:thermometer",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.BODY_TEMP_C,
MeasureType.BODY_TEMPERATURE,
"Body Temperature",
const.UOM_TEMP_C,
"mdi:thermometer",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SKIN_TEMP_C,
MeasureType.SKIN_TEMPERATURE,
"Skin Temperature",
const.UOM_TEMP_C,
"mdi:thermometer",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.FAT_RATIO_PCT,
MeasureType.FAT_RATIO,
"Fat Ratio",
PERCENTAGE,
None,
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.DIASTOLIC_MMHG,
MeasureType.DIASTOLIC_BLOOD_PRESSURE,
"Diastolic Blood Pressure",
const.UOM_MMHG,
None,
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SYSTOLIC_MMGH,
MeasureType.SYSTOLIC_BLOOD_PRESSURE,
"Systolic Blood Pressure",
const.UOM_MMHG,
None,
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.HEART_PULSE_BPM,
MeasureType.HEART_RATE,
"Heart Pulse",
const.UOM_BEATS_PER_MINUTE,
"mdi:heart-pulse",
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SPO2_PCT,
MeasureType.SP02,
"SP02",
PERCENTAGE,
None,
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.HYDRATION,
MeasureType.HYDRATION,
"Hydration",
MASS_KILOGRAMS,
"mdi:water",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.PWV,
MeasureType.PULSE_WAVE_VELOCITY,
"Pulse Wave Velocity",
SPEED_METERS_PER_SECOND,
None,
SENSOR_DOMAIN,
True,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_BREATHING_DISTURBANCES_INTENSITY,
GetSleepSummaryField.BREATHING_DISTURBANCES_INTENSITY,
"Breathing disturbances intensity",
"",
"",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_DEEP_DURATION_SECONDS,
GetSleepSummaryField.DEEP_SLEEP_DURATION,
"Deep sleep",
TIME_SECONDS,
"mdi:sleep",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_TOSLEEP_DURATION_SECONDS,
GetSleepSummaryField.DURATION_TO_SLEEP,
"Time to sleep",
TIME_SECONDS,
"mdi:sleep",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_TOWAKEUP_DURATION_SECONDS,
GetSleepSummaryField.DURATION_TO_WAKEUP,
"Time to wakeup",
TIME_SECONDS,
"mdi:sleep-off",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_HEART_RATE_AVERAGE,
GetSleepSummaryField.HR_AVERAGE,
"Average heart rate",
const.UOM_BEATS_PER_MINUTE,
"mdi:heart-pulse",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_HEART_RATE_MAX,
GetSleepSummaryField.HR_MAX,
"Maximum heart rate",
const.UOM_BEATS_PER_MINUTE,
"mdi:heart-pulse",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_HEART_RATE_MIN,
GetSleepSummaryField.HR_MIN,
"Minimum heart rate",
const.UOM_BEATS_PER_MINUTE,
"mdi:heart-pulse",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_LIGHT_DURATION_SECONDS,
GetSleepSummaryField.LIGHT_SLEEP_DURATION,
"Light sleep",
TIME_SECONDS,
"mdi:sleep",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_REM_DURATION_SECONDS,
GetSleepSummaryField.REM_SLEEP_DURATION,
"REM sleep",
TIME_SECONDS,
"mdi:sleep",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_RESPIRATORY_RATE_AVERAGE,
GetSleepSummaryField.RR_AVERAGE,
"Average respiratory rate",
const.UOM_BREATHS_PER_MINUTE,
None,
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_RESPIRATORY_RATE_MAX,
GetSleepSummaryField.RR_MAX,
"Maximum respiratory rate",
const.UOM_BREATHS_PER_MINUTE,
None,
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_RESPIRATORY_RATE_MIN,
GetSleepSummaryField.RR_MIN,
"Minimum respiratory rate",
const.UOM_BREATHS_PER_MINUTE,
None,
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_SCORE,
GetSleepSummaryField.SLEEP_SCORE,
"Sleep score",
const.SCORE_POINTS,
"mdi:medal",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_SNORING,
GetSleepSummaryField.SNORING,
"Snoring",
"",
None,
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_SNORING_EPISODE_COUNT,
GetSleepSummaryField.SNORING_EPISODE_COUNT,
"Snoring episode count",
"",
None,
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_WAKEUP_COUNT,
GetSleepSummaryField.WAKEUP_COUNT,
"Wakeup count",
const.UOM_FREQUENCY,
"mdi:sleep-off",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
WithingsAttribute(
Measurement.SLEEP_WAKEUP_DURATION_SECONDS,
GetSleepSummaryField.WAKEUP_DURATION,
"Wakeup time",
TIME_SECONDS,
"mdi:sleep-off",
SENSOR_DOMAIN,
False,
UpdateType.POLL,
),
# Webhook measurements.
WithingsAttribute(
Measurement.IN_BED,
NotifyAppli.BED_IN,
"In bed",
"",
"mdi:bed",
BINARY_SENSOR_DOMAIN,
True,
UpdateType.WEBHOOK,
),
]
WITHINGS_MEASUREMENTS_MAP: Dict[Measurement, WithingsAttribute] = {
attr.measurement: attr for attr in WITHINGS_ATTRIBUTES
}
WITHINGS_MEASURE_TYPE_MAP: Dict[
Union[NotifyAppli, GetSleepSummaryField, MeasureType], WithingsAttribute
] = {attr.measute_type: attr for attr in WITHINGS_ATTRIBUTES}
class ConfigEntryWithingsApi(AbstractWithingsApi):
"""Withing API that uses HA resources."""
def __init__(
self,
hass: HomeAssistant,
config_entry: ConfigEntry,
implementation: AbstractOAuth2Implementation,
):
"""Initialize object."""
self._hass = hass
self._config_entry = config_entry
self._implementation = implementation
self.session = OAuth2Session(hass, config_entry, implementation)
def _request(
self, path: str, params: Dict[str, Any], method: str = "GET"
) -> Dict[str, Any]:
"""Perform an async request."""
asyncio.run_coroutine_threadsafe(
self.session.async_ensure_token_valid(), self._hass.loop
)
access_token = self._config_entry.data["token"]["access_token"]
response = requests.request(
method,
f"{self.URL}/{path}",
params=params,
headers={"Authorization": f"Bearer {access_token}"},
)
return response.json()
def json_message_response(message: str, message_code: int) -> Response:
"""Produce common json output."""
return HomeAssistantView.json({"message": message, "code": message_code}, 200)
class WebhookAvailability(IntEnum):
"""Represents various statuses of webhook availability."""
SUCCESS = 0
CONNECT_ERROR = 1
HTTP_ERROR = 2
NOT_WEBHOOK = 3
class WebhookUpdateCoordinator:
"""Coordinates webhook data updates across listeners."""
def __init__(self, hass: HomeAssistant, user_id: int) -> None:
"""Initialize the object."""
self._hass = hass
self._user_id = user_id
self._listeners: List[CALLBACK_TYPE] = []
self.data: MeasurementData = {}
def async_add_listener(self, listener: CALLBACK_TYPE) -> Callable[[], None]:
"""Add a listener."""
self._listeners.append(listener)
@callback
def remove_listener() -> None:
self.async_remove_listener(listener)
return remove_listener
def async_remove_listener(self, listener: CALLBACK_TYPE) -> None:
"""Remove a listener."""
self._listeners.remove(listener)
def update_data(self, measurement: Measurement, value: Any) -> None:
"""Update the data object and notify listeners the data has changed."""
self.data[measurement] = value
self.notify_data_changed()
def notify_data_changed(self) -> None:
"""Notify all listeners the data has changed."""
for listener in self._listeners:
listener()
class DataManager:
"""Manage withing data."""
def __init__(
self,
hass: HomeAssistant,
profile: str,
api: ConfigEntryWithingsApi,
user_id: int,
webhook_config: WebhookConfig,
):
"""Initialize the data manager."""
self._hass = hass
self._api = api
self._user_id = user_id
self._profile = profile
self._webhook_config = webhook_config
self._notify_subscribe_delay = datetime.timedelta(seconds=5)
self._notify_unsubscribe_delay = datetime.timedelta(seconds=1)
self._is_available = True
self._cancel_interval_update_interval: Optional[CALLBACK_TYPE] = None
self._cancel_configure_webhook_subscribe_interval: Optional[
CALLBACK_TYPE
] = None
self._api_notification_id = f"withings_{self._user_id}"
self.subscription_update_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="subscription_update_coordinator",
update_interval=timedelta(minutes=120),
update_method=self.async_subscribe_webhook,
)
self.poll_data_update_coordinator = DataUpdateCoordinator[
Dict[MeasureType, Any]
](
hass,
_LOGGER,
name="poll_data_update_coordinator",
update_interval=timedelta(minutes=120)
if self._webhook_config.enabled
else timedelta(minutes=10),
update_method=self.async_get_all_data,
)
self.webhook_update_coordinator = WebhookUpdateCoordinator(
self._hass, self._user_id
)
self._cancel_subscription_update: Optional[Callable[[], None]] = None
self._subscribe_webhook_run_count = 0
@property
def webhook_config(self) -> WebhookConfig:
"""Get the webhook config."""
return self._webhook_config
@property
def user_id(self) -> int:
"""Get the user_id of the authenticated user."""
return self._user_id
@property
def profile(self) -> str:
"""Get the profile."""
return self._profile
def async_start_polling_webhook_subscriptions(self) -> None:
"""Start polling webhook subscriptions (if enabled) to reconcile their setup."""
self.async_stop_polling_webhook_subscriptions()
def empty_listener() -> None:
pass
self._cancel_subscription_update = (
self.subscription_update_coordinator.async_add_listener(empty_listener)
)
def async_stop_polling_webhook_subscriptions(self) -> None:
"""Stop polling webhook subscriptions."""
if self._cancel_subscription_update:
self._cancel_subscription_update()
self._cancel_subscription_update = None
async def _do_retry(self, func, attempts=3) -> Any:
"""Retry a function call.
Withings' API occasionally and incorrectly throws errors. Retrying the call tends to work.
"""
exception = None
for attempt in range(1, attempts + 1):
_LOGGER.debug("Attempt %s of %s", attempt, attempts)
try:
return await func()
except Exception as exception1: # pylint: disable=broad-except
await asyncio.sleep(0.1)
exception = exception1
continue
if exception:
raise exception
async def async_subscribe_webhook(self) -> None:
"""Subscribe the webhook to withings data updates."""
return await self._do_retry(self._async_subscribe_webhook)
async def _async_subscribe_webhook(self) -> None:
_LOGGER.debug("Configuring withings webhook")
# On first startup, perform a fresh re-subscribe. Withings stops pushing data
# if the webhook fails enough times but they don't remove the old subscription
# config. This ensures the subscription is setup correctly and they start
# pushing again.
if self._subscribe_webhook_run_count == 0:
_LOGGER.debug("Refreshing withings webhook configs")
await self.async_unsubscribe_webhook()
self._subscribe_webhook_run_count += 1
# Get the current webhooks.
response = await self._hass.async_add_executor_job(self._api.notify_list)
subscribed_applis = frozenset(
[
profile.appli
for profile in response.profiles
if profile.callbackurl == self._webhook_config.url
]
)
# Determine what subscriptions need to be created.
ignored_applis = frozenset({NotifyAppli.USER})
to_add_applis = frozenset(
[
appli
for appli in NotifyAppli
if appli not in subscribed_applis and appli not in ignored_applis
]
)
# Subscribe to each one.
for appli in to_add_applis:
_LOGGER.debug(
"Subscribing %s for %s in %s seconds",
self._webhook_config.url,
appli,
self._notify_subscribe_delay.total_seconds(),
)
# Withings will HTTP HEAD the callback_url and needs some downtime
# between each call or there is a higher chance of failure.
await asyncio.sleep(self._notify_subscribe_delay.total_seconds())
await self._hass.async_add_executor_job(
self._api.notify_subscribe, self._webhook_config.url, appli
)
async def async_unsubscribe_webhook(self) -> None:
"""Unsubscribe webhook from withings data updates."""
return await self._do_retry(self._async_unsubscribe_webhook)
async def _async_unsubscribe_webhook(self) -> None:
# Get the current webhooks.
response = await self._hass.async_add_executor_job(self._api.notify_list)
# Revoke subscriptions.
for profile in response.profiles:
_LOGGER.debug(
"Unsubscribing %s for %s in %s seconds",
profile.callbackurl,
profile.appli,
self._notify_unsubscribe_delay.total_seconds(),
)
# Quick calls to Withings can result in the service returning errors. Give them
# some time to cool down.
await asyncio.sleep(self._notify_subscribe_delay.total_seconds())
await self._hass.async_add_executor_job(
self._api.notify_revoke, profile.callbackurl, profile.appli
)
async def async_get_all_data(self) -> Optional[Dict[MeasureType, Any]]:
"""Update all withings data."""
try:
return await self._do_retry(self._async_get_all_data)
except Exception as exception:
# User is not authenticated.
if isinstance(
exception, (UnauthorizedException, AuthFailedException)
) or NOT_AUTHENTICATED_ERROR.match(str(exception)):
context = {
const.PROFILE: self._profile,
"userid": self._user_id,
"source": "reauth",
}
# Check if reauth flow already exists.
flow = next(
iter(
flow
for flow in self._hass.config_entries.flow.async_progress()
if flow.context == context
),
None,
)
if flow:
return
# Start a reauth flow.
await self._hass.config_entries.flow.async_init(
const.DOMAIN,
context=context,
)
return
raise exception
async def _async_get_all_data(self) -> Optional[Dict[MeasureType, Any]]:
_LOGGER.info("Updating all withings data")
return {
**await self.async_get_measures(),
**await self.async_get_sleep_summary(),
}
async def async_get_measures(self) -> Dict[MeasureType, Any]:
"""Get the measures data."""
_LOGGER.debug("Updating withings measures")
response = await self._hass.async_add_executor_job(self._api.measure_get_meas)
# Sort from oldest to newest.
groups = sorted(
query_measure_groups(
response, MeasureTypes.ANY, MeasureGroupAttribs.UNAMBIGUOUS
),
key=lambda group: group.created.datetime,
reverse=False,
)
return {
WITHINGS_MEASURE_TYPE_MAP[measure.type].measurement: round(
float(measure.value * pow(10, measure.unit)), 2
)
for group in groups
for measure in group.measures
}
async def async_get_sleep_summary(self) -> Dict[MeasureType, Any]:
"""Get the sleep summary data."""
_LOGGER.debug("Updating withing sleep summary")
now = dt.utcnow()
yesterday = now - datetime.timedelta(days=1)
yesterday_noon = datetime.datetime(
yesterday.year,
yesterday.month,
yesterday.day,
12,
0,
0,
0,
datetime.timezone.utc,
)
def get_sleep_summary() -> SleepGetSummaryResponse:
return self._api.sleep_get_summary(
lastupdate=yesterday_noon,
data_fields=[
GetSleepSummaryField.BREATHING_DISTURBANCES_INTENSITY,
GetSleepSummaryField.DEEP_SLEEP_DURATION,
GetSleepSummaryField.DURATION_TO_SLEEP,
GetSleepSummaryField.DURATION_TO_WAKEUP,
GetSleepSummaryField.HR_AVERAGE,
GetSleepSummaryField.HR_MAX,
GetSleepSummaryField.HR_MIN,
GetSleepSummaryField.LIGHT_SLEEP_DURATION,
GetSleepSummaryField.REM_SLEEP_DURATION,
GetSleepSummaryField.RR_AVERAGE,
GetSleepSummaryField.RR_MAX,
GetSleepSummaryField.RR_MIN,
GetSleepSummaryField.SLEEP_SCORE,
GetSleepSummaryField.SNORING,
GetSleepSummaryField.SNORING_EPISODE_COUNT,
GetSleepSummaryField.WAKEUP_COUNT,
GetSleepSummaryField.WAKEUP_DURATION,
],
)
response = await self._hass.async_add_executor_job(get_sleep_summary)
# Set the default to empty lists.
raw_values: Dict[GetSleepSummaryField, List[int]] = {
field: [] for field in GetSleepSummaryField
}
# Collect the raw data.
for serie in response.series:
data = serie.data
for field in GetSleepSummaryField:
raw_values[field].append(data._asdict()[field.value])
values: Dict[GetSleepSummaryField, float] = {}
def average(data: List[int]) -> float:
return sum(data) / len(data)
def set_value(field: GetSleepSummaryField, func: Callable) -> None:
non_nones = [
value for value in raw_values.get(field, []) if value is not None
]
values[field] = func(non_nones) if non_nones else None
set_value(GetSleepSummaryField.BREATHING_DISTURBANCES_INTENSITY, average)
set_value(GetSleepSummaryField.DEEP_SLEEP_DURATION, sum)
set_value(GetSleepSummaryField.DURATION_TO_SLEEP, average)
set_value(GetSleepSummaryField.DURATION_TO_WAKEUP, average)
set_value(GetSleepSummaryField.HR_AVERAGE, average)
set_value(GetSleepSummaryField.HR_MAX, average)
set_value(GetSleepSummaryField.HR_MIN, average)
set_value(GetSleepSummaryField.LIGHT_SLEEP_DURATION, sum)
set_value(GetSleepSummaryField.REM_SLEEP_DURATION, sum)
set_value(GetSleepSummaryField.RR_AVERAGE, average)
set_value(GetSleepSummaryField.RR_MAX, average)
set_value(GetSleepSummaryField.RR_MIN, average)
set_value(GetSleepSummaryField.SLEEP_SCORE, max)
set_value(GetSleepSummaryField.SNORING, average)
set_value(GetSleepSummaryField.SNORING_EPISODE_COUNT, sum)
set_value(GetSleepSummaryField.WAKEUP_COUNT, sum)
set_value(GetSleepSummaryField.WAKEUP_DURATION, average)
return {
WITHINGS_MEASURE_TYPE_MAP[field].measurement: round(value, 4)
if value is not None
else None
for field, value in values.items()
}
async def async_webhook_data_updated(self, data_category: NotifyAppli) -> None:
"""Handle scenario when data is updated from a webook."""
_LOGGER.debug("Withings webhook triggered")
if data_category in {
NotifyAppli.WEIGHT,
NotifyAppli.CIRCULATORY,
NotifyAppli.SLEEP,
}:
await self.poll_data_update_coordinator.async_request_refresh()
elif data_category in {NotifyAppli.BED_IN, NotifyAppli.BED_OUT}:
self.webhook_update_coordinator.update_data(
Measurement.IN_BED, data_category == NotifyAppli.BED_IN
)
def get_attribute_unique_id(attribute: WithingsAttribute, user_id: int) -> str:
"""Get a entity unique id for a user's attribute."""
return f"withings_{user_id}_{attribute.measurement.value}"
async def async_get_entity_id(
hass: HomeAssistant, attribute: WithingsAttribute, user_id: int
) -> Optional[str]:
"""Get an entity id for a user's attribute."""
entity_registry: EntityRegistry = (
await hass.helpers.entity_registry.async_get_registry()
)
unique_id = get_attribute_unique_id(attribute, user_id)
entity_id = entity_registry.async_get_entity_id(
attribute.platform, const.DOMAIN, unique_id
)
if entity_id is None:
_LOGGER.error("Cannot find entity id for unique_id: %s", unique_id)
return None
return entity_id
class BaseWithingsSensor(Entity):
"""Base class for withings sensors."""
def __init__(self, data_manager: DataManager, attribute: WithingsAttribute) -> None:
"""Initialize the Withings sensor."""
self._data_manager = data_manager
self._attribute = attribute
self._profile = self._data_manager.profile
self._user_id = self._data_manager.user_id
self._name = f"Withings {self._attribute.measurement.value} {self._profile}"
self._unique_id = get_attribute_unique_id(self._attribute, self._user_id)
self._state_data: Optional[Any] = None
@property
def should_poll(self) -> bool:
"""Return False to indicate HA should not poll for changes."""
return False
@property
def name(self) -> str:
"""Return the name of the sensor."""
return self._name
@property
def available(self) -> bool:
"""Return True if entity is available."""
if self._attribute.update_type == UpdateType.POLL:
return self._data_manager.poll_data_update_coordinator.last_update_success
if self._attribute.update_type == UpdateType.WEBHOOK:
return self._data_manager.webhook_config.enabled and (
self._attribute.measurement
in self._data_manager.webhook_update_coordinator.data
)
return True
@property
def unique_id(self) -> str:
"""Return a unique, Home Assistant friendly identifier for this entity."""
return self._unique_id
@property
def unit_of_measurement(self) -> str:
"""Return the unit of measurement of this entity, if any."""
return self._attribute.unit_of_measurement
@property
def icon(self) -> str:
"""Icon to use in the frontend, if any."""
return self._attribute.icon
@property
def entity_registry_enabled_default(self) -> bool:
"""Return if the entity should be enabled when first added to the entity registry."""
return self._attribute.enabled_by_default
@callback
def _on_poll_data_updated(self) -> None:
self._update_state_data(
self._data_manager.poll_data_update_coordinator.data or {}
)
@callback
def _on_webhook_data_updated(self) -> None:
self._update_state_data(
self._data_manager.webhook_update_coordinator.data or {}
)
def _update_state_data(self, data: MeasurementData) -> None:
"""Update the state data."""
self._state_data = data.get(self._attribute.measurement)
self.async_write_ha_state()
async def async_added_to_hass(self) -> None:
"""Register update dispatcher."""
if self._attribute.update_type == UpdateType.POLL:
self.async_on_remove(
self._data_manager.poll_data_update_coordinator.async_add_listener(
self._on_poll_data_updated
)
)
self._on_poll_data_updated()
elif self._attribute.update_type == UpdateType.WEBHOOK:
self.async_on_remove(
self._data_manager.webhook_update_coordinator.async_add_listener(
self._on_webhook_data_updated
)
)
self._on_webhook_data_updated()
async def async_get_data_manager(
hass: HomeAssistant, config_entry: ConfigEntry
) -> DataManager:
"""Get the data manager for a config entry."""
hass.data.setdefault(const.DOMAIN, {})
hass.data[const.DOMAIN].setdefault(config_entry.entry_id, {})
config_entry_data = hass.data[const.DOMAIN][config_entry.entry_id]
if const.DATA_MANAGER not in config_entry_data:
profile = config_entry.data.get(const.PROFILE)
_LOGGER.debug("Creating withings data manager for profile: %s", profile)
config_entry_data[const.DATA_MANAGER] = DataManager(
hass,
profile,
ConfigEntryWithingsApi(
hass=hass,
config_entry=config_entry,
implementation=await config_entry_oauth2_flow.async_get_config_entry_implementation(
hass, config_entry
),
),
config_entry.data["token"]["userid"],
WebhookConfig(
id=config_entry.data[CONF_WEBHOOK_ID],
url=config_entry.data[const.CONF_WEBHOOK_URL],
enabled=config_entry.data[const.CONF_USE_WEBHOOK],
),
)
return config_entry_data[const.DATA_MANAGER]
def get_data_manager_by_webhook_id(
hass: HomeAssistant, webhook_id: str
) -> Optional[DataManager]:
"""Get a data manager by it's webhook id."""
return next(
iter(
[
data_manager
for data_manager in get_all_data_managers(hass)
if data_manager.webhook_config.id == webhook_id
]
),
None,
)
def get_all_data_managers(hass: HomeAssistant) -> Tuple[DataManager, ...]:
"""Get all configured data managers."""
return tuple(
[
config_entry_data[const.DATA_MANAGER]
for config_entry_data in hass.data[const.DOMAIN].values()
if const.DATA_MANAGER in config_entry_data
]
)
def async_remove_data_manager(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
"""Remove a data manager for a config entry."""
del hass.data[const.DOMAIN][config_entry.entry_id][const.DATA_MANAGER]
async def async_create_entities(
hass: HomeAssistant,
entry: ConfigEntry,
create_func: Callable[[DataManager, WithingsAttribute], Entity],
platform: str,
) -> List[Entity]:
"""Create withings entities from config entry."""
data_manager = await async_get_data_manager(hass, entry)
return [
create_func(data_manager, attribute)
for attribute in get_platform_attributes(platform)
]
def get_platform_attributes(platform: str) -> Tuple[WithingsAttribute, ...]:
"""Get withings attributes used for a specific platform."""
return tuple(
[
attribute
for attribute in WITHINGS_ATTRIBUTES
if attribute.platform == platform
]
)
class WithingsLocalOAuth2Implementation(LocalOAuth2Implementation):
"""Oauth2 implementation that only uses the external url."""
@property
def redirect_uri(self) -> str:
"""Return the redirect uri."""
url = get_url(self.hass, allow_internal=False, prefer_cloud=True)
return f"{url}{AUTH_CALLBACK_PATH}"
| turbokongen/home-assistant | homeassistant/components/withings/common.py | Python | apache-2.0 | 34,960 | 0.00083 |
"""
QFileDialog objects can only be run in the main thread.
"""
### imports ###################################################################
import os
import time
from PySide2 import QtCore
from PySide2 import QtWidgets
from pycmds.project import project_globals as g
from pycmds.project import classes as pc
### FileDialog object #########################################################
directory_filepath = pc.Mutex()
open_filepath = pc.Mutex()
save_filepath = pc.Mutex()
class FileDialog(QtCore.QObject):
update_ui = QtCore.Signal()
queue_emptied = QtCore.Signal()
def __init__(self, enqueued_object, busy_object):
QtCore.QObject.__init__(self)
self.name = "file_dialog"
self.enqueued = enqueued_object
self.busy = busy_object
@QtCore.Slot(str, list)
def dequeue(self, method, inputs):
"""
Slot to accept enqueued commands from main thread.
Method passed as qstring, inputs as list of [args, kwargs].
Calls own method with arguments from inputs.
"""
self.update_ui.emit()
method = str(method) # method passed as qstring
args, kwargs = inputs
if g.debug.read():
print(self.name, " dequeue:", method, inputs, self.busy.read())
self.enqueued.pop()
getattr(self, method)(*args, **kwargs)
if not self.enqueued.read():
self.queue_emptied.emit()
self.check_busy()
def check_busy(self):
"""
decides if the hardware is done and handles writing of 'busy' to False
"""
# must always write busy whether answer is True or False
if self.enqueued.read():
time.sleep(0.1) # don't loop like crazy
self.busy.write(True)
else:
self.busy.write(False)
self.update_ui.emit()
def clean(self, out):
"""
takes the output and returns a string that has the properties I want
"""
out = str(out)
out = out.replace("/", os.sep)
return out
def getExistingDirectory(self, inputs=[]):
caption, directory, options = inputs
options = QtWidgets.QFileDialog.ShowDirsOnly
out = self.clean(
QtWidgets.QFileDialog.getExistingDirectory(
g.main_window.read(), caption, str(directory), options
)
)
directory_filepath.write(out)
def getOpenFileName(self, inputs=[]):
caption, directory, options = inputs
out = self.clean(
QtWidgets.QFileDialog.getOpenFileName(
g.main_window.read(), caption, str(directory), options
)[0]
)
open_filepath.write(out)
def getSaveFileName(self, inputs=[]):
caption, directory, savefilter, selectedfilter, options = inputs
out = self.clean(
QtWidgets.QFileDialog.getSaveFileName(
g.main_window.read(), caption, directory, savefilter, selectedfilter, options,
)[0]
)
save_filepath.write(out)
busy = pc.Busy()
enqueued = pc.Enqueued()
file_dialog = FileDialog(enqueued, busy)
q = pc.Q(enqueued, busy, file_dialog)
### thread-safe file dialog methods ###########################################
# the q method only works between different threads
# call directly if the calling object is in the main thread
def dir_dialog(caption, directory, options=None):
inputs = [caption, directory, options]
if QtCore.QThread.currentThread() == g.main_thread.read():
file_dialog.getExistingDirectory(inputs)
else:
q.push("getExistingDirectory", inputs)
while busy.read():
time.sleep(0.1)
return directory_filepath.read()
def open_dialog(caption, directory, options):
inputs = [caption, directory, options]
if QtCore.QThread.currentThread() == g.main_thread.read():
file_dialog.getOpenFileName(inputs)
else:
q.push("getOpenFileName", inputs)
while busy.read():
time.sleep(0.1)
return open_filepath.read()
def save_dialog(caption, directory, savefilter, selectedfilter, options):
inputs = [caption, directory, savefilter, selectedfilter, options]
if QtCore.QThread.currentThread() == g.main_thread.read():
file_dialog.getSaveFileName(inputs)
else:
q.push("getSaveFileName", inputs)
while busy.read():
time.sleep(0.1)
return save_filepath.read()
| wright-group/PyCMDS | pycmds/project/file_dialog_handler.py | Python | mit | 4,481 | 0.000893 |
#!usr/bin/env python
#
# Copyright 2013 Matthew Wall
# See the file LICENSE.txt for your full rights.
#
# Thanks to Kenneth Lavrsen for the Open2300 implementation:
# http://www.lavrsen.dk/foswiki/bin/view/Open2300/WebHome
# description of the station communication interface:
# http://www.lavrsen.dk/foswiki/bin/view/Open2300/OpenWSAPI
# memory map:
# http://www.lavrsen.dk/foswiki/bin/view/Open2300/OpenWSMemoryMap
#
# Thanks to Russell Stuart for the ws2300 python implementation:
# http://ace-host.stuart.id.au/russell/files/ws2300/
# and the map of the station memory:
# http://ace-host.stuart.id.au/russell/files/ws2300/memory_map_2300.txt
#
# This immplementation copies directly from Russell Stuart's implementation,
# but only the parts required to read from and write to the weather station.
"""Classes and functions for interfacing with WS-23xx weather stations.
LaCrosse made a number of stations in the 23xx series, including:
WS-2300, WS-2308, WS-2310, WS-2315, WS-2317, WS-2357
The stations were also sold as the TFA Matrix and TechnoLine 2350.
The WWVB receiver is located in the console.
To synchronize the console and sensors, press and hold the PLUS key for 2
seconds. When console is not synchronized no data will be received.
To do a factory reset, press and hold PRESSURE and WIND for 5 seconds.
A single bucket tip is 0.0204 in (0.518 mm).
The station has 175 history records. That is just over 7 days of data with
the default history recording interval of 60 minutes.
The station supports both wireless and wired communication between the
sensors and a station console. Wired connection updates data every 8 seconds.
Wireless connection updates data in 16 to 128 second intervals, depending on
wind speed and rain activity.
The connection type can be one of 0=cable, 3=lost, 15=wireless
sensor update frequency:
32 seconds when wind speed > 22.36 mph (wireless)
128 seconds when wind speed < 22.36 mph (wireless)
10 minutes (wireless after 5 failed attempts)
8 seconds (wired)
console update frequency:
15 seconds (pressure/temperature)
20 seconds (humidity)
It is possible to increase the rate of wireless updates:
http://www.wxforum.net/index.php?topic=2196.0
Sensors are connected by unshielded phone cables. RF interference can cause
random spikes in data, with one symptom being values of 25.5 m/s or 91.8 km/h
for the wind speed. To reduce the number of spikes in data, replace with
shielded cables:
http://www.lavrsen.dk/sources/weather/windmod.htm
The station records wind speed and direction, but has no notion of gust.
The station calculates windchill and dewpoint.
The station has a serial connection to the computer.
This driver does not keep the serial port open for long periods. Instead, the
driver opens the serial port, reads data, then closes the port.
This driver polls the station. Use the polling_interval parameter to specify
how often to poll for data. If not specified, the polling interval will adapt
based on connection type and status.
USB-Serial Converters
With a USB-serial converter one can connect the station to a computer with
only USB ports, but not every converter will work properly. Perhaps the two
most common converters are based on the Prolific and FTDI chipsets. Many
people report better luck with the FTDI-based converters. Some converters
that use the Prolific chipset (PL2303) will work, but not all of them.
Known to work: ATEN UC-232A
Bounds checking
wind speed: 0-113 mph
wind direction: 0-360
humidity: 0-100
temperature: ok if not -22F and humidity is valid
dewpoint: ok if not -22F and humidity is valid
barometer: 25-35 inHg
rain rate: 0-10 in/hr
Discrepancies Between Implementations
As of December 2013, there are significant differences between the open2300,
wview, and ws2300 implementations. Current version numbers are as follows:
open2300 1.11
ws2300 1.8
wview 5.20.2
History Interval
The factory default is 60 minutes. The value stored in the console is one
less than the actual value (in minutes). So for the factory default of 60,
the console stores 59. The minimum interval is 1.
ws2300.py reports the actual value from the console, e.g., 59 when the
interval is 60. open2300 reports the interval, e.g., 60 when the interval
is 60. wview ignores the interval.
Detecting Bogus Sensor Values
wview queries the station 3 times for each sensor then accepts the value only
if the three values were close to each other.
open2300 sleeps 10 seconds if a wind measurement indicates invalid or overflow.
The ws2300.py implementation includes overflow and validity flags for values
from the wind sensors. It does not retry based on invalid or overflow.
Wind Speed
There is disagreement about how to calculate wind speed and how to determine
whether the wind speed is valid.
This driver introduces a WindConversion object that uses open2300/wview
decoding so that wind speeds match that of open2300/wview. ws2300 1.8
incorrectly uses bcd2num instead of bin2num. This bug is fixed in this driver.
The memory map indicates the following:
addr smpl description
0x527 0 Wind overflow flag: 0 = normal
0x528 0 Wind minimum code: 0=min, 1=--.-, 2=OFL
0x529 0 Windspeed: binary nibble 0 [m/s * 10]
0x52A 0 Windspeed: binary nibble 1 [m/s * 10]
0x52B 0 Windspeed: binary nibble 2 [m/s * 10]
0x52C 8 Wind Direction = nibble * 22.5 degrees
0x52D 8 Wind Direction 1 measurement ago
0x52E 9 Wind Direction 2 measurement ago
0x52F 8 Wind Direction 3 measurement ago
0x530 7 Wind Direction 4 measurement ago
0x531 7 Wind Direction 5 measurement ago
0x532 0
wview 5.20.2 implementation (wview apparently copied from open2300):
read 3 bytes starting at 0x527
0x527 x[0]
0x528 x[1]
0x529 x[2]
if ((x[0] != 0x00) ||
((x[1] == 0xff) && (((x[2] & 0xf) == 0) || ((x[2] & 0xf) == 1)))) {
fail
} else {
dir = (x[2] >> 4) * 22.5
speed = ((((x[2] & 0xf) << 8) + (x[1])) / 10.0 * 2.23693629)
maxdir = dir
maxspeed = speed
}
open2300 1.10 implementation:
read 6 bytes starting at 0x527
0x527 x[0]
0x528 x[1]
0x529 x[2]
0x52a x[3]
0x52b x[4]
0x52c x[5]
if ((x[0] != 0x00) ||
((x[1] == 0xff) && (((x[2] & 0xf) == 0) || ((x[2] & 0xf) == 1)))) {
sleep 10
} else {
dir = x[2] >> 4
speed = ((((x[2] & 0xf) << 8) + (x[1])) / 10.0)
dir0 = (x[2] >> 4) * 22.5
dir1 = (x[3] & 0xf) * 22.5
dir2 = (x[3] >> 4) * 22.5
dir3 = (x[4] & 0xf) * 22.5
dir4 = (x[4] >> 4) * 22.5
dir5 = (x[5] & 0xf) * 22.5
}
ws2300.py 1.8 implementation:
read 1 nibble starting at 0x527
read 1 nibble starting at 0x528
read 4 nibble starting at 0x529
read 3 nibble starting at 0x529
read 1 nibble starting at 0x52c
read 1 nibble starting at 0x52d
read 1 nibble starting at 0x52e
read 1 nibble starting at 0x52f
read 1 nibble starting at 0x530
read 1 nibble starting at 0x531
0x527 overflow
0x528 validity
0x529 speed[0]
0x52a speed[1]
0x52b speed[2]
0x52c dir[0]
speed: ((x[2] * 100 + x[1] * 10 + x[0]) % 1000) / 10
velocity: (x[2] * 100 + x[1] * 10 + x[0]) / 10
dir = data[0] * 22.5
speed = (bcd2num(data) % 10**3 + 0) / 10**1
velocity = (bcd2num(data[:3])/10.0, bin2num(data[3:4]) * 22.5)
bcd2num([a,b,c]) -> c*100+b*10+a
"""
# TODO: use pyserial instead of LinuxSerialPort
# TODO: put the __enter__ and __exit__ scaffolding on serial port, not Station
# FIXME: unless we can get setTime to work, just ignore the console clock
# FIXME: detect bogus wind speed/direction
# i see these when the wind instrument is disconnected:
# ws 26.399999
# wsh 21
# w0 135
from __future__ import with_statement
import syslog
import time
import string
import fcntl
import os
import select
import struct
import termios
import tty
import weeutil.weeutil
import weewx
import weewx.drivers
import weewx.units
import weewx.wxformulas
DRIVER_NAME = 'WS23xx'
DRIVER_VERSION = '0.22'
def loader(config_dict, _):
return WS23xxDriver(config_dict=config_dict, **config_dict[DRIVER_NAME])
def configurator_loader(_):
return WS23xxConfigurator()
def confeditor_loader():
return WS23xxConfEditor()
DEFAULT_PORT = '/dev/ttyUSB0'
def logmsg(dst, msg):
syslog.syslog(dst, 'ws23xx: %s' % msg)
def logdbg(msg):
logmsg(syslog.LOG_DEBUG, msg)
def loginf(msg):
logmsg(syslog.LOG_INFO, msg)
def logcrt(msg):
logmsg(syslog.LOG_CRIT, msg)
def logerr(msg):
logmsg(syslog.LOG_ERR, msg)
class WS23xxConfigurator(weewx.drivers.AbstractConfigurator):
def add_options(self, parser):
super(WS23xxConfigurator, self).add_options(parser)
parser.add_option("--info", dest="info", action="store_true",
help="display weather station configuration")
parser.add_option("--current", dest="current", action="store_true",
help="get the current weather conditions")
parser.add_option("--history", dest="nrecords", type=int, metavar="N",
help="display N history records")
parser.add_option("--history-since", dest="recmin",
type=int, metavar="N",
help="display history records since N minutes ago")
parser.add_option("--clear-memory", dest="clear", action="store_true",
help="clear station memory")
parser.add_option("--set-time", dest="settime", action="store_true",
help="set the station clock to the current time")
parser.add_option("--set-interval", dest="interval",
type=int, metavar="N",
help="set the station archive interval to N minutes")
def do_options(self, options, parser, config_dict, prompt):
self.station = WS23xxDriver(**config_dict[DRIVER_NAME])
if options.current:
self.show_current()
elif options.nrecords is not None:
self.show_history(count=options.nrecords)
elif options.recmin is not None:
ts = int(time.time()) - options.recmin * 60
self.show_history(ts=ts)
elif options.settime:
self.set_clock(prompt)
elif options.interval is not None:
self.set_interval(options.interval, prompt)
elif options.clear:
self.clear_history(prompt)
else:
self.show_info()
self.station.closePort()
def show_info(self):
"""Query the station then display the settings."""
print 'Querying the station for the configuration...'
config = self.station.getConfig()
for key in sorted(config):
print '%s: %s' % (key, config[key])
def show_current(self):
"""Get current weather observation."""
print 'Querying the station for current weather data...'
for packet in self.station.genLoopPackets():
print packet
break
def show_history(self, ts=None, count=0):
"""Show the indicated number of records or records since timestamp"""
print "Querying the station for historical records..."
for i, r in enumerate(self.station.genStartupRecords(since_ts=ts,
count=count)):
print r
if count and i > count:
break
def set_clock(self, prompt):
"""Set station clock to current time."""
ans = None
while ans not in ['y', 'n']:
v = self.station.getTime()
vstr = weeutil.weeutil.timestamp_to_string(v)
print "Station clock is", vstr
if prompt:
ans = raw_input("Set station clock (y/n)? ")
else:
print "Setting station clock"
ans = 'y'
if ans == 'y':
self.station.setTime()
v = self.station.getTime()
vstr = weeutil.weeutil.timestamp_to_string(v)
print "Station clock is now", vstr
elif ans == 'n':
print "Set clock cancelled."
def set_interval(self, interval, prompt):
print "Changing the interval will clear the station memory."
v = self.station.getArchiveInterval()
ans = None
while ans not in ['y', 'n']:
print "Interval is", v
if prompt:
ans = raw_input("Set interval to %d minutes (y/n)? " % interval)
else:
print "Setting interval to %d minutes" % interval
ans = 'y'
if ans == 'y':
self.station.setArchiveInterval(interval)
v = self.station.getArchiveInterval()
print "Interval is now", v
elif ans == 'n':
print "Set interval cancelled."
def clear_history(self, prompt):
ans = None
while ans not in ['y', 'n']:
v = self.station.getRecordCount()
print "Records in memory:", v
if prompt:
ans = raw_input("Clear console memory (y/n)? ")
else:
print 'Clearing console memory'
ans = 'y'
if ans == 'y':
self.station.clearHistory()
v = self.station.getRecordCount()
print "Records in memory:", v
elif ans == 'n':
print "Clear memory cancelled."
class WS23xxDriver(weewx.drivers.AbstractDevice):
"""Driver for LaCrosse WS23xx stations."""
def __init__(self, **stn_dict):
"""Initialize the station object.
port: The serial port, e.g., /dev/ttyS0 or /dev/ttyUSB0
[Required. Default is /dev/ttyS0]
polling_interval: How often to poll the station, in seconds.
[Optional. Default is 8 (wired) or 30 (wireless)]
model: Which station model is this?
[Optional. Default is 'LaCrosse WS23xx']
"""
self._last_rain = None
self._last_cn = None
self._poll_wait = 60
self.model = stn_dict.get('model', 'LaCrosse WS23xx')
self.port = stn_dict.get('port', DEFAULT_PORT)
self.max_tries = int(stn_dict.get('max_tries', 5))
self.retry_wait = int(stn_dict.get('retry_wait', 30))
self.polling_interval = stn_dict.get('polling_interval', None)
if self.polling_interval is not None:
self.polling_interval = int(self.polling_interval)
loginf('driver version is %s' % DRIVER_VERSION)
loginf('serial port is %s' % self.port)
loginf('polling interval is %s' % self.polling_interval)
@property
def hardware_name(self):
return self.model
# weewx wants the archive interval in seconds, but the console uses minutes
@property
def archive_interval(self):
return self.getArchiveInterval() * 60
# def closePort(self):
# pass
def genLoopPackets(self):
ntries = 0
while ntries < self.max_tries:
ntries += 1
try:
with WS23xx(self.port) as s:
data = s.get_raw_data(SENSOR_IDS)
packet = data_to_packet(data, int(time.time() + 0.5),
last_rain=self._last_rain)
self._last_rain = packet['rainTotal']
ntries = 0
yield packet
if self.polling_interval is not None:
self._poll_wait = self.polling_interval
if data['cn'] != self._last_cn:
conn_info = get_conn_info(data['cn'])
loginf("connection changed from %s to %s" %
(get_conn_info(self._last_cn)[0], conn_info[0]))
self._last_cn = data['cn']
if self.polling_interval is None:
loginf("using %s second polling interval"
" for %s connection" %
(conn_info[1], conn_info[0]))
self._poll_wait = conn_info[1]
time.sleep(self._poll_wait)
except Ws2300.Ws2300Exception, e:
logerr("Failed attempt %d of %d to get LOOP data: %s" %
(ntries, self.max_tries, e))
logdbg("Waiting %d seconds before retry" % self.retry_wait)
time.sleep(self.retry_wait)
else:
msg = "Max retries (%d) exceeded for LOOP data" % self.max_tries
logerr(msg)
raise weewx.RetriesExceeded(msg)
def genArchiveRecords(self, since_ts, count=0):
with WS23xx(self.port) as s:
last_rain = None
for ts, data in s.gen_records(since_ts=since_ts, count=count):
record = data_to_packet(data, ts, last_rain=last_rain)
record['interval'] = data['interval']
last_rain = record['rainTotal']
yield record
# def getTime(self) :
# with WS23xx(self.port) as s:
# return s.get_time()
# def setTime(self):
# with WS23xx(self.port) as s:
# s.set_time()
def getArchiveInterval(self):
with WS23xx(self.port) as s:
return s.get_archive_interval()
def setArchiveInterval(self, interval):
with WS23xx(self.port) as s:
s.set_archive_interval(interval)
def getConfig(self):
with WS23xx(self.port) as s:
data = s.get_raw_data(Measure.IDS.keys())
fdata = {}
for key in data:
fdata[Measure.IDS[key].name] = data[key]
return fdata
def getRecordCount(self):
with WS23xx(self.port) as s:
return s.get_record_count()
def clearHistory(self):
with WS23xx(self.port) as s:
s.clear_memory()
# ids for current weather conditions and connection type
SENSOR_IDS = ['it','ih','ot','oh','pa','wind','rh','rt','dp','wc','cn']
# polling interval, in seconds, for various connection types
POLLING_INTERVAL = {0: ("cable", 8), 3: ("lost", 60), 15: ("wireless", 30)}
def get_conn_info(conn_type):
return POLLING_INTERVAL.get(conn_type, ("unknown", 60))
def data_to_packet(data, ts, last_rain=None):
"""Convert raw data to format and units required by weewx.
station weewx (metric)
temperature degree C degree C
humidity percent percent
uv index unitless unitless
pressure mbar mbar
wind speed m/s km/h
wind dir degree degree
wind gust None
wind gust dir None
rain mm cm
rain rate cm/h
"""
packet = dict()
packet['usUnits'] = weewx.METRIC
packet['dateTime'] = ts
packet['inTemp'] = data['it']
packet['inHumidity'] = data['ih']
packet['outTemp'] = data['ot']
packet['outHumidity'] = data['oh']
packet['pressure'] = data['pa']
ws, wd, wso, wsv = data['wind']
if wso == 0 and wsv == 0:
packet['windSpeed'] = ws
if packet['windSpeed'] is not None:
packet['windSpeed'] *= 3.6 # weewx wants km/h
packet['windDir'] = wd if packet['windSpeed'] else None
else:
loginf('invalid wind reading: speed=%s dir=%s overflow=%s invalid=%s' %
(ws, wd, wso, wsv))
packet['windSpeed'] = None
packet['windDir'] = None
packet['windGust'] = None
packet['windGustDir'] = None
packet['rainTotal'] = data['rt']
if packet['rainTotal'] is not None:
packet['rainTotal'] /= 10 # weewx wants cm
packet['rain'] = weewx.wxformulas.calculate_rain(
packet['rainTotal'], last_rain)
# station provides some derived variables
packet['rainRate'] = data['rh']
if packet['rainRate'] is not None:
packet['rainRate'] /= 10 # weewx wants cm/hr
packet['dewpoint'] = data['dp']
packet['windchill'] = data['wc']
return packet
class WS23xx(object):
"""Wrap the Ws2300 object so we can easily open serial port, read/write,
close serial port without all of the try/except/finally scaffolding."""
def __init__(self, port):
logdbg('create LinuxSerialPort')
self.serial_port = LinuxSerialPort(port)
logdbg('create Ws2300')
self.ws = Ws2300(self.serial_port)
def __enter__(self):
logdbg('station enter')
return self
def __exit__(self, type, value, traceback):
logdbg('station exit')
self.ws = None
self.close()
def close(self):
logdbg('close LinuxSerialPort')
self.serial_port.close()
self.serial_port = None
def set_time(self, ts):
"""Set station time to indicated unix epoch."""
logdbg('setting station clock to %s' %
weeutil.weeutil.timestamp_to_string(ts))
for m in [Measure.IDS['sd'], Measure.IDS['st']]:
data = m.conv.value2binary(ts)
cmd = m.conv.write(data, None)
self.ws.write_safe(m.address, *cmd[1:])
def get_time(self):
"""Return station time as unix epoch."""
data = self.get_raw_data(['sw'])
ts = int(data['sw'])
logdbg('station clock is %s' % weeutil.weeutil.timestamp_to_string(ts))
return ts
def set_archive_interval(self, interval):
"""Set the archive interval in minutes."""
if int(interval) < 1:
raise ValueError('archive interval must be greater than zero')
logdbg('setting hardware archive interval to %s minutes' % interval)
interval -= 1
for m,v in [(Measure.IDS['hi'],interval), # archive interval in minutes
(Measure.IDS['hc'],1), # time till next sample in minutes
(Measure.IDS['hn'],0)]: # number of valid records
data = m.conv.value2binary(v)
cmd = m.conv.write(data, None)
self.ws.write_safe(m.address, *cmd[1:])
def get_archive_interval(self):
"""Return archive interval in minutes."""
data = self.get_raw_data(['hi'])
x = 1 + int(data['hi'])
logdbg('station archive interval is %s minutes' % x)
return x
def clear_memory(self):
"""Clear station memory."""
logdbg('clearing console memory')
for m,v in [(Measure.IDS['hn'],0)]: # number of valid records
data = m.conv.value2binary(v)
cmd = m.conv.write(data, None)
self.ws.write_safe(m.address, *cmd[1:])
def get_record_count(self):
data = self.get_raw_data(['hn'])
x = int(data['hn'])
logdbg('record count is %s' % x)
return x
def gen_records(self, since_ts=None, count=None, use_computer_clock=True):
"""Get latest count records from the station from oldest to newest. If
count is 0 or None, return all records.
The station has a history interval, and it records when the last
history sample was saved. So as long as the interval does not change
between the first and last records, we are safe to infer timestamps
for each record. This assumes that if the station loses power then
the memory will be cleared.
There is no timestamp associated with each record - we have to guess.
The station tells us the time until the next record and the epoch of
the latest record, based on the station's clock. So we can use that
or use the computer clock to guess the timestamp for each record.
To ensure accurate data, the first record must be read within one
minute of the initial read and the remaining records must be read
within numrec * interval minutes.
"""
logdbg("gen_records: since_ts=%s count=%s clock=%s" %
(since_ts, count, use_computer_clock))
measures = [Measure.IDS['hi'], Measure.IDS['hw'],
Measure.IDS['hc'], Measure.IDS['hn']]
raw_data = read_measurements(self.ws, measures)
interval = 1 + int(measures[0].conv.binary2value(raw_data[0])) # minute
latest_ts = int(measures[1].conv.binary2value(raw_data[1])) # epoch
time_to_next = int(measures[2].conv.binary2value(raw_data[2])) # minute
numrec = int(measures[3].conv.binary2value(raw_data[3]))
now = int(time.time())
cstr = 'station'
if use_computer_clock:
latest_ts = now - (interval - time_to_next) * 60
cstr = 'computer'
logdbg("using %s clock with latest_ts of %s" %
(cstr, weeutil.weeutil.timestamp_to_string(latest_ts)))
if not count:
count = HistoryMeasure.MAX_HISTORY_RECORDS
if since_ts is not None:
count = int((now - since_ts) / (interval * 60))
logdbg("count is %d to satisfy timestamp of %s" %
(count, weeutil.weeutil.timestamp_to_string(since_ts)))
if count == 0:
return
if count > numrec:
count = numrec
if count > HistoryMeasure.MAX_HISTORY_RECORDS:
count = HistoryMeasure.MAX_HISTORY_RECORDS
# station is about to overwrite first record, so skip it
if time_to_next <= 1 and count == HistoryMeasure.MAX_HISTORY_RECORDS:
count -= 1
logdbg("downloading %d records from station" % count)
HistoryMeasure.set_constants(self.ws)
measures = [HistoryMeasure(n) for n in range(count-1, -1, -1)]
raw_data = read_measurements(self.ws, measures)
last_ts = latest_ts - (count-1) * interval * 60
for measure, nybbles in zip(measures, raw_data):
value = measure.conv.binary2value(nybbles)
data_dict = {
'interval': interval,
'it': value.temp_indoor,
'ih': value.humidity_indoor,
'ot': value.temp_outdoor,
'oh': value.humidity_outdoor,
'pa': value.pressure_absolute,
'rt': value.rain,
'wind': (value.wind_speed, value.wind_direction, 0, 0),
'rh': None, # no rain rate in history
'dp': None, # no dewpoint in history
'wc': None, # no windchill in history
}
yield last_ts, data_dict
last_ts += interval * 60
def get_raw_data(self, labels):
"""Get raw data from the station, return as dictionary."""
measures = [Measure.IDS[m] for m in labels]
raw_data = read_measurements(self.ws, measures)
data_dict = dict(zip(labels, [m.conv.binary2value(d) for m, d in zip(measures, raw_data)]))
return data_dict
# =============================================================================
# The following code was adapted from ws2300.py by Russell Stuart
# =============================================================================
VERSION = "1.8 2013-08-26"
#
# Debug options.
#
DEBUG_SERIAL = False
#
# A fatal error.
#
class FatalError(StandardError):
source = None
message = None
cause = None
def __init__(self, source, message, cause=None):
self.source = source
self.message = message
self.cause = cause
StandardError.__init__(self, message)
#
# The serial port interface. We can talk to the Ws2300 over anything
# that implements this interface.
#
class SerialPort(object):
#
# Discard all characters waiting to be read.
#
def clear(self): raise NotImplementedError()
#
# Close the serial port.
#
def close(self): raise NotImplementedError()
#
# Wait for all characters to be sent.
#
def flush(self): raise NotImplementedError()
#
# Read a character, waiting for a most timeout seconds. Return the
# character read, or None if the timeout occurred.
#
def read_byte(self, timeout): raise NotImplementedError()
#
# Release the serial port. Closes it until it is used again, when
# it is automatically re-opened. It need not be implemented.
#
def release(self): pass
#
# Write characters to the serial port.
#
def write(self, data): raise NotImplementedError()
#
# A Linux Serial port. Implements the Serial interface on Linux.
#
class LinuxSerialPort(SerialPort):
SERIAL_CSIZE = {
"7": tty.CS7,
"8": tty.CS8, }
SERIAL_PARITIES= {
"e": tty.PARENB,
"n": 0,
"o": tty.PARENB|tty.PARODD, }
SERIAL_SPEEDS = {
"300": tty.B300,
"600": tty.B600,
"1200": tty.B1200,
"2400": tty.B2400,
"4800": tty.B4800,
"9600": tty.B9600,
"19200": tty.B19200,
"38400": tty.B38400,
"57600": tty.B57600,
"115200": tty.B115200, }
SERIAL_SETTINGS = "2400,n,8,1"
device = None # string, the device name.
orig_settings = None # class, the original ports settings.
select_list = None # list, The serial ports
serial_port = None # int, OS handle to device.
settings = None # string, the settings on the command line.
#
# Initialise ourselves.
#
def __init__(self,device,settings=SERIAL_SETTINGS):
self.device = device
self.settings = settings.split(",")
self.settings.extend([None,None,None])
self.settings[0] = self.__class__.SERIAL_SPEEDS.get(self.settings[0], None)
self.settings[1] = self.__class__.SERIAL_PARITIES.get(self.settings[1].lower(), None)
self.settings[2] = self.__class__.SERIAL_CSIZE.get(self.settings[2], None)
if len(self.settings) != 7 or None in self.settings[:3]:
raise FatalError(self.device, 'Bad serial settings "%s".' % settings)
self.settings = self.settings[:4]
#
# Open the port.
#
try:
self.serial_port = os.open(self.device, os.O_RDWR)
except EnvironmentError, e:
raise FatalError(self.device, "can't open tty device - %s." % str(e))
try:
fcntl.flock(self.serial_port, fcntl.LOCK_EX)
self.orig_settings = tty.tcgetattr(self.serial_port)
setup = self.orig_settings[:]
setup[0] = tty.INPCK
setup[1] = 0
setup[2] = tty.CREAD|tty.HUPCL|tty.CLOCAL|reduce(lambda x,y: x|y, self.settings[:3])
setup[3] = 0 # tty.ICANON
setup[4] = self.settings[0]
setup[5] = self.settings[0]
setup[6] = ['\000']*len(setup[6])
setup[6][tty.VMIN] = 1
setup[6][tty.VTIME] = 0
tty.tcflush(self.serial_port, tty.TCIOFLUSH)
#
# Restart IO if stopped using software flow control (^S/^Q). This
# doesn't work on FreeBSD.
#
try:
tty.tcflow(self.serial_port, tty.TCOON|tty.TCION)
except termios.error:
pass
tty.tcsetattr(self.serial_port, tty.TCSAFLUSH, setup)
#
# Set DTR low and RTS high and leave other control lines untouched.
#
arg = struct.pack('I', 0)
arg = fcntl.ioctl(self.serial_port, tty.TIOCMGET, arg)
portstatus = struct.unpack('I', arg)[0]
portstatus = portstatus & ~tty.TIOCM_DTR | tty.TIOCM_RTS
arg = struct.pack('I', portstatus)
fcntl.ioctl(self.serial_port, tty.TIOCMSET, arg)
self.select_list = [self.serial_port]
except Exception:
os.close(self.serial_port)
raise
def close(self):
if self.orig_settings:
tty.tcsetattr(self.serial_port, tty.TCSANOW, self.orig_settings)
os.close(self.serial_port)
def read_byte(self, timeout):
ready = select.select(self.select_list, [], [], timeout)
if not ready[0]:
return None
return os.read(self.serial_port, 1)
#
# Write a string to the port.
#
def write(self, data):
os.write(self.serial_port, data)
#
# Flush the input buffer.
#
def clear(self):
tty.tcflush(self.serial_port, tty.TCIFLUSH)
#
# Flush the output buffer.
#
def flush(self):
tty.tcdrain(self.serial_port)
#
# This class reads and writes bytes to a Ws2300. It is passed something
# that implements the Serial interface. The major routines are:
#
# Ws2300() - Create one of these objects that talks over the serial port.
# read_batch() - Reads data from the device using an scatter/gather interface.
# write_safe() - Writes data to the device.
#
class Ws2300(object):
#
# An exception for us.
#
class Ws2300Exception(StandardError):
def __init__(self, *args):
StandardError.__init__(self, *args)
#
# Constants we use.
#
MAXBLOCK = 30
MAXRETRIES = 50
MAXWINDRETRIES= 20
WRITENIB = 0x42
SETBIT = 0x12
UNSETBIT = 0x32
WRITEACK = 0x10
SETACK = 0x04
UNSETACK = 0x0C
RESET_MIN = 0x01
RESET_MAX = 0x02
MAX_RESETS = 100
#
# Instance data.
#
log_buffer = None # list, action log
log_mode = None # string, Log mode
long_nest = None # int, Nesting of log actions
serial_port = None # string, SerialPort port to use
#
# Initialise ourselves.
#
def __init__(self,serial_port):
self.log_buffer = []
self.log_nest = 0
self.serial_port = serial_port
#
# Write data to the device.
#
def write_byte(self,data):
if self.log_mode != 'w':
if self.log_mode != 'e':
self.log(' ')
self.log_mode = 'w'
self.log("%02x" % ord(data))
self.serial_port.write(data)
#
# Read a byte from the device.
#
def read_byte(self, timeout=1.0):
if self.log_mode != 'r':
self.log_mode = 'r'
self.log(':')
result = self.serial_port.read_byte(timeout)
if result == None:
self.log("--")
else:
self.log("%02x" % ord(result))
return result
#
# Remove all pending incoming characters.
#
def clear_device(self):
if self.log_mode != 'e':
self.log(' ')
self.log_mode = 'c'
self.log("C")
self.serial_port.clear()
#
# Write a reset string and wait for a reply.
#
def reset_06(self):
self.log_enter("re")
try:
for retry in range(self.__class__.MAX_RESETS):
self.clear_device()
self.write_byte('\x06')
#
# Occasionally 0, then 2 is returned. If 0 comes back,
# continue reading as this is more efficient than sending
# an out-of sync reset and letting the data reads restore
# synchronization. Occasionally, multiple 2's are returned.
# Read with a fast timeout until all data is exhausted, if
# we got a 2 back at all, we consider it a success.
#
success = False
answer = self.read_byte()
while answer != None:
if answer == '\x02':
success = True
answer = self.read_byte(0.05)
if success:
return
msg = "Reset failed, %d retries, no response" % self.__class__.MAX_RESETS
raise self.Ws2300Exception(msg)
finally:
self.log_exit()
#
# Encode the address.
#
def write_address(self,address):
for digit in range(4):
byte = chr((address >> (4 * (3-digit)) & 0xF) * 4 + 0x82)
self.write_byte(byte)
ack = chr(digit * 16 + (ord(byte) - 0x82) // 4)
answer = self.read_byte()
if ack != answer:
self.log("??")
return False
return True
#
# Write data, checking the reply.
#
def write_data(self,nybble_address,nybbles,encode_constant=None):
self.log_enter("wd")
try:
if not self.write_address(nybble_address):
return None
if encode_constant == None:
encode_constant = self.WRITENIB
encoded_data = ''.join([
chr(nybbles[i]*4 + encode_constant)
for i in range(len(nybbles))])
ack_constant = {
self.SETBIT: self.SETACK,
self.UNSETBIT: self.UNSETACK,
self.WRITENIB: self.WRITEACK
}[encode_constant]
self.log(",")
for i in range(len(encoded_data)):
self.write_byte(encoded_data[i])
answer = self.read_byte()
if chr(nybbles[i] + ack_constant) != answer:
self.log("??")
return None
return True
finally:
self.log_exit()
#
# Reset the device and write a command, verifing it was written correctly.
#
def write_safe(self,nybble_address,nybbles,encode_constant=None):
self.log_enter("ws")
try:
for retry in range(self.MAXRETRIES):
self.reset_06()
command_data = self.write_data(nybble_address,nybbles,encode_constant)
if command_data != None:
return command_data
raise self.Ws2300Exception("write_safe failed, retries exceeded")
finally:
self.log_exit()
#
# A total kuldge this, but its the easiest way to force the 'computer
# time' to look like a normal ws2300 variable, which it most definitely
# isn't, of course.
#
def read_computer_time(self,nybble_address,nybble_count):
now = time.time()
tm = time.localtime(now)
tu = time.gmtime(now)
year2 = tm[0] % 100
datetime_data = (
tu[5]%10, tu[5]//10, tu[4]%10, tu[4]//10, tu[3]%10, tu[3]//10,
tm[5]%10, tm[5]//10, tm[4]%10, tm[4]//10, tm[3]%10, tm[3]//10,
tm[2]%10, tm[2]//10, tm[1]%10, tm[1]//10, year2%10, year2//10)
address = nybble_address+18
return datetime_data[address:address+nybble_count]
#
# Read 'length' nybbles at address. Returns: (nybble_at_address, ...).
# Can't read more than MAXBLOCK nybbles at a time.
#
def read_data(self,nybble_address,nybble_count):
if nybble_address < 0:
return self.read_computer_time(nybble_address,nybble_count)
self.log_enter("rd")
try:
if nybble_count < 1 or nybble_count > self.MAXBLOCK:
StandardError("Too many nybbles requested")
bytes = (nybble_count + 1) // 2
if not self.write_address(nybble_address):
return None
#
# Write the number bytes we want to read.
#
encoded_data = chr(0xC2 + bytes*4)
self.write_byte(encoded_data)
answer = self.read_byte()
check = chr(0x30 + bytes)
if answer != check:
self.log("??")
return None
#
# Read the response.
#
self.log(", :")
response = ""
for i in range(bytes):
answer = self.read_byte()
if answer == None:
return None
response += answer
#
# Read and verify checksum
#
answer = self.read_byte()
checksum = sum([ord(b) for b in response]) % 256
if chr(checksum) != answer:
self.log("??")
return None
flatten = lambda a,b: a + (ord(b) % 16, ord(b) / 16)
return reduce(flatten, response, ())[:nybble_count]
finally:
self.log_exit()
#
# Read a batch of blocks. Batches is a list of data to be read:
# [(address_of_first_nybble, length_in_nybbles), ...]
# returns:
# [(nybble_at_address, ...), ...]
#
def read_batch(self,batches):
self.log_enter("rb start")
self.log_exit()
try:
if [b for b in batches if b[0] >= 0]:
self.reset_06()
result = []
for batch in batches:
address = batch[0]
data = ()
for start_pos in range(0,batch[1],self.MAXBLOCK):
for retry in range(self.MAXRETRIES):
bytes = min(self.MAXBLOCK, batch[1]-start_pos)
response = self.read_data(address + start_pos, bytes)
if response != None:
break
self.reset_06()
if response == None:
raise self.Ws2300Exception("read failed, retries exceeded")
data += response
result.append(data)
return result
finally:
self.log_enter("rb end")
self.log_exit()
#
# Reset the device, read a block of nybbles at the passed address.
#
def read_safe(self,nybble_address,nybble_count):
self.log_enter("rs")
try:
return self.read_batch([(nybble_address,nybble_count)])[0]
finally:
self.log_exit()
#
# Debug logging of serial IO.
#
def log(self, s):
if not DEBUG_SERIAL:
return
self.log_buffer[-1] = self.log_buffer[-1] + s
def log_enter(self, action):
if not DEBUG_SERIAL:
return
self.log_nest += 1
if self.log_nest == 1:
if len(self.log_buffer) > 1000:
del self.log_buffer[0]
self.log_buffer.append("%5.2f %s " % (time.time() % 100, action))
self.log_mode = 'e'
def log_exit(self):
if not DEBUG_SERIAL:
return
self.log_nest -= 1
#
# Print a data block.
#
def bcd2num(nybbles):
digits = list(nybbles)[:]
digits.reverse()
return reduce(lambda a,b: a*10 + b, digits, 0)
def num2bcd(number, nybble_count):
result = []
for i in range(nybble_count):
result.append(int(number % 10))
number //= 10
return tuple(result)
def bin2num(nybbles):
digits = list(nybbles)
digits.reverse()
return reduce(lambda a,b: a*16 + b, digits, 0)
def num2bin(number, nybble_count):
result = []
number = int(number)
for i in range(nybble_count):
result.append(number % 16)
number //= 16
return tuple(result)
#
# A "Conversion" encapsulates a unit of measurement on the Ws2300. Eg
# temperature, or wind speed.
#
class Conversion(object):
description = None # Description of the units.
nybble_count = None # Number of nybbles used on the WS2300
units = None # Units name (eg hPa).
#
# Initialise ourselves.
# units - text description of the units.
# nybble_count- Size of stored value on ws2300 in nybbles
# description - Description of the units
#
def __init__(self, units, nybble_count, description):
self.description = description
self.nybble_count = nybble_count
self.units = units
#
# Convert the nybbles read from the ws2300 to our internal value.
#
def binary2value(self, data): raise NotImplementedError()
#
# Convert our internal value to nybbles that can be written to the ws2300.
#
def value2binary(self, value): raise NotImplementedError()
#
# Print value.
#
def str(self, value): raise NotImplementedError()
#
# Convert the string produced by "str()" back to the value.
#
def parse(self, s): raise NotImplementedError()
#
# Transform data into something that can be written. Returns:
# (new_bytes, ws2300.write_safe_args, ...)
# This only becomes tricky when less than a nybble is written.
#
def write(self, data, nybble):
return (data, data)
#
# Test if the nybbles read from the Ws2300 is sensible. Sometimes a
# communications error will make it past the weak checksums the Ws2300
# uses. This optional function implements another layer of checking -
# does the value returned make sense. Returns True if the value looks
# like garbage.
#
def garbage(self, data):
return False
#
# For values stores as binary numbers.
#
class BinConversion(Conversion):
mult = None
scale = None
units = None
def __init__(self, units, nybble_count, scale, description, mult=1, check=None):
Conversion.__init__(self, units, nybble_count, description)
self.mult = mult
self.scale = scale
self.units = units
def binary2value(self, data):
return (bin2num(data) * self.mult) / 10.0**self.scale
def value2binary(self, value):
return num2bin(int(value * 10**self.scale) // self.mult, self.nybble_count)
def str(self, value):
return "%.*f" % (self.scale, value)
def parse(self, s):
return float(s)
#
# For values stored as BCD numbers.
#
class BcdConversion(Conversion):
offset = None
scale = None
units = None
def __init__(self, units, nybble_count, scale, description, offset=0):
Conversion.__init__(self, units, nybble_count, description)
self.offset = offset
self.scale = scale
self.units = units
def binary2value(self, data):
num = bcd2num(data) % 10**self.nybble_count + self.offset
return float(num) / 10**self.scale
def value2binary(self, value):
return num2bcd(int(value * 10**self.scale) - self.offset, self.nybble_count)
def str(self, value):
return "%.*f" % (self.scale, value)
def parse(self, s):
return float(s)
#
# For pressures. Add a garbage check.
#
class PressureConversion(BcdConversion):
def __init__(self):
BcdConversion.__init__(self, "hPa", 5, 1, "pressure")
def garbage(self, data):
value = self.binary2value(data)
return value < 900 or value > 1200
#
# For values the represent a date.
#
class ConversionDate(Conversion):
format = None
def __init__(self, nybble_count, format):
description = format
for xlate in "%Y:yyyy,%m:mm,%d:dd,%H:hh,%M:mm,%S:ss".split(","):
description = description.replace(*xlate.split(":"))
Conversion.__init__(self, "", nybble_count, description)
self.format = format
def str(self, value):
return time.strftime(self.format, time.localtime(value))
def parse(self, s):
return time.mktime(time.strptime(s, self.format))
class DateConversion(ConversionDate):
def __init__(self):
ConversionDate.__init__(self, 6, "%Y-%m-%d")
def binary2value(self, data):
x = bcd2num(data)
return time.mktime((
x // 10000 % 100,
x // 100 % 100,
x % 100,
0,
0,
0,
0,
0,
0))
def value2binary(self, value):
tm = time.localtime(value)
dt = tm[2] + tm[1] * 100 + (tm[0]-2000) * 10000
return num2bcd(dt, self.nybble_count)
class DatetimeConversion(ConversionDate):
def __init__(self):
ConversionDate.__init__(self, 11, "%Y-%m-%d %H:%M")
def binary2value(self, data):
x = bcd2num(data)
return time.mktime((
x // 1000000000 % 100 + 2000,
x // 10000000 % 100,
x // 100000 % 100,
x // 100 % 100,
x % 100,
0,
0,
0,
0))
def value2binary(self, value):
tm = time.localtime(value)
dow = tm[6] + 1
dt = tm[4]+(tm[3]+(dow+(tm[2]+(tm[1]+(tm[0]-2000)*100)*100)*10)*100)*100
return num2bcd(dt, self.nybble_count)
class UnixtimeConversion(ConversionDate):
def __init__(self):
ConversionDate.__init__(self, 12, "%Y-%m-%d %H:%M:%S")
def binary2value(self, data):
x = bcd2num(data)
return time.mktime((
x //10000000000 % 100 + 2000,
x // 100000000 % 100,
x // 1000000 % 100,
x // 10000 % 100,
x // 100 % 100,
x % 100,
0,
0,
0))
def value2binary(self, value):
tm = time.localtime(value)
dt = tm[5]+(tm[4]+(tm[3]+(tm[2]+(tm[1]+(tm[0]-2000)*100)*100)*100)*100)*100
return num2bcd(dt, self.nybble_count)
class TimestampConversion(ConversionDate):
def __init__(self):
ConversionDate.__init__(self, 10, "%Y-%m-%d %H:%M")
def binary2value(self, data):
x = bcd2num(data)
return time.mktime((
x // 100000000 % 100 + 2000,
x // 1000000 % 100,
x // 10000 % 100,
x // 100 % 100,
x % 100,
0,
0,
0,
0))
def value2binary(self, value):
tm = time.localtime(value)
dt = tm[4] + (tm[3] + (tm[2] + (tm[1] + (tm[0]-2000)*100)*100)*100)*100
return num2bcd(dt, self.nybble_count)
class TimeConversion(ConversionDate):
def __init__(self):
ConversionDate.__init__(self, 6, "%H:%M:%S")
def binary2value(self, data):
x = bcd2num(data)
return time.mktime((
0,
0,
0,
x // 10000 % 100,
x // 100 % 100,
x % 100,
0,
0,
0)) - time.timezone
def value2binary(self, value):
tm = time.localtime(value)
dt = tm[5] + tm[4]*100 + tm[3]*10000
return num2bcd(dt, self.nybble_count)
def parse(self, s):
return time.mktime((0,0,0) + time.strptime(s, self.format)[3:]) + time.timezone
class WindDirectionConversion(Conversion):
def __init__(self):
Conversion.__init__(self, "deg", 1, "North=0 clockwise")
def binary2value(self, data):
return data[0] * 22.5
def value2binary(self, value):
return (int((value + 11.25) / 22.5),)
def str(self, value):
return "%g" % value
def parse(self, s):
return float(s)
class WindVelocityConversion(Conversion):
def __init__(self):
Conversion.__init__(self, "ms,d", 4, "wind speed and direction")
def binary2value(self, data):
return (bin2num(data[:3])/10.0, bin2num(data[3:4]) * 22.5)
def value2binary(self, value):
return num2bin(value[0]*10, 3) + num2bin((value[1] + 11.5) / 22.5, 1)
def str(self, value):
return "%.1f,%g" % value
def parse(self, s):
return tuple([float(x) for x in s.split(",")])
# The ws2300 1.8 implementation does not calculate wind speed correctly -
# it uses bcd2num instead of bin2num. This conversion object uses bin2num
# decoding and it reads all wind data in a single transcation so that we do
# not suffer coherency problems.
class WindConversion(Conversion):
def __init__(self):
Conversion.__init__(self, "ms,d,o,v", 12, "wind speed, dir, validity")
def binary2value(self, data):
overflow = data[0]
validity = data[1]
speed = bin2num(data[2:5]) / 10.0
direction = data[5] * 22.5
return (speed, direction, overflow, validity)
def str(self, value):
return "%.1f,%g,%s,%s" % value
def parse(self, s):
return tuple([float(x) for x in s.split(",")])
#
# For non-numerical values.
#
class TextConversion(Conversion):
constants = None
def __init__(self, constants):
items = constants.items()[:]
items.sort()
fullname = ",".join([c[1]+"="+str(c[0]) for c in items]) + ",unknown-X"
Conversion.__init__(self, "", 1, fullname)
self.constants = constants
def binary2value(self, data):
return data[0]
def value2binary(self, value):
return (value,)
def str(self, value):
result = self.constants.get(value, None)
if result != None:
return result
return "unknown-%d" % value
def parse(self, s):
result = [c[0] for c in self.constants.items() if c[1] == s]
if result:
return result[0]
return None
#
# For values that are represented by one bit.
#
class ConversionBit(Conversion):
bit = None
desc = None
def __init__(self, bit, desc):
self.bit = bit
self.desc = desc
Conversion.__init__(self, "", 1, desc[0] + "=0," + desc[1] + "=1")
def binary2value(self, data):
return data[0] & (1 << self.bit) and 1 or 0
def value2binary(self, value):
return (value << self.bit,)
def str(self, value):
return self.desc[value]
def parse(self, s):
return [c[0] for c in self.desc.items() if c[1] == s][0]
class BitConversion(ConversionBit):
def __init__(self, bit, desc):
ConversionBit.__init__(self, bit, desc)
#
# Since Ws2300.write_safe() only writes nybbles and we have just one bit,
# we have to insert that bit into the data_read so it can be written as
# a nybble.
#
def write(self, data, nybble):
data = (nybble & ~(1 << self.bit) | data[0],)
return (data, data)
class AlarmSetConversion(BitConversion):
bit = None
desc = None
def __init__(self, bit):
BitConversion.__init__(self, bit, {0:"off", 1:"on"})
class AlarmActiveConversion(BitConversion):
bit = None
desc = None
def __init__(self, bit):
BitConversion.__init__(self, bit, {0:"inactive", 1:"active"})
#
# For values that are represented by one bit, and must be written as
# a single bit.
#
class SetresetConversion(ConversionBit):
bit = None
def __init__(self, bit, desc):
ConversionBit.__init__(self, bit, desc)
#
# Setreset bits use a special write mode.
#
def write(self, data, nybble):
if data[0] == 0:
operation = Ws2300.UNSETBIT
else:
operation = Ws2300.SETBIT
return ((nybble & ~(1 << self.bit) | data[0],), [self.bit], operation)
#
# Conversion for history. This kludge makes history fit into the framework
# used for all the other measures.
#
class HistoryConversion(Conversion):
class HistoryRecord(object):
temp_indoor = None
temp_outdoor = None
pressure_absolute = None
humidity_indoor = None
humidity_outdoor = None
rain = None
wind_speed = None
wind_direction = None
def __str__(self):
return "%4.1fc %2d%% %4.1fc %2d%% %6.1fhPa %6.1fmm %2dm/s %5g" % (
self.temp_indoor, self.humidity_indoor,
self.temp_outdoor, self.humidity_outdoor,
self.pressure_absolute, self.rain,
self.wind_speed, self.wind_direction)
def parse(cls, s):
rec = cls()
toks = [tok.rstrip(string.ascii_letters + "%/") for tok in s.split()]
rec.temp_indoor = float(toks[0])
rec.humidity_indoor = int(toks[1])
rec.temp_outdoor = float(toks[2])
rec.humidity_outdoor = int(toks[3])
rec.pressure_absolute = float(toks[4])
rec.rain = float(toks[5])
rec.wind_speed = int(toks[6])
rec.wind_direction = int((float(toks[7]) + 11.25) / 22.5) % 16
return rec
parse = classmethod(parse)
def __init__(self):
Conversion.__init__(self, "", 19, "history")
def binary2value(self, data):
value = self.__class__.HistoryRecord()
n = bin2num(data[0:5])
value.temp_indoor = (n % 1000) / 10.0 - 30
value.temp_outdoor = (n - (n % 1000)) / 10000.0 - 30
n = bin2num(data[5:10])
value.pressure_absolute = (n % 10000) / 10.0
if value.pressure_absolute < 500:
value.pressure_absolute += 1000
value.humidity_indoor = (n - (n % 10000)) / 10000.0
value.humidity_outdoor = bcd2num(data[10:12])
value.rain = bin2num(data[12:15]) * 0.518
value.wind_speed = bin2num(data[15:18])
value.wind_direction = bin2num(data[18:19]) * 22.5
return value
def value2binary(self, value):
result = ()
n = int((value.temp_indoor + 30) * 10.0 + (value.temp_outdoor + 30) * 10000.0 + 0.5)
result = result + num2bin(n, 5)
n = value.pressure_absolute % 1000
n = int(n * 10.0 + value.humidity_indoor * 10000.0 + 0.5)
result = result + num2bin(n, 5)
result = result + num2bcd(value.humidity_outdoor, 2)
result = result + num2bin(int((value.rain + 0.518/2) / 0.518), 3)
result = result + num2bin(value.wind_speed, 3)
result = result + num2bin(value.wind_direction, 1)
return result
#
# Print value.
#
def str(self, value):
return str(value)
#
# Convert the string produced by "str()" back to the value.
#
def parse(self, s):
return self.__class__.HistoryRecord.parse(s)
#
# Various conversions we know about.
#
conv_ala0 = AlarmActiveConversion(0)
conv_ala1 = AlarmActiveConversion(1)
conv_ala2 = AlarmActiveConversion(2)
conv_ala3 = AlarmActiveConversion(3)
conv_als0 = AlarmSetConversion(0)
conv_als1 = AlarmSetConversion(1)
conv_als2 = AlarmSetConversion(2)
conv_als3 = AlarmSetConversion(3)
conv_buzz = SetresetConversion(3, {0:'on', 1:'off'})
conv_lbck = SetresetConversion(0, {0:'off', 1:'on'})
conv_date = DateConversion()
conv_dtme = DatetimeConversion()
conv_utme = UnixtimeConversion()
conv_hist = HistoryConversion()
conv_stmp = TimestampConversion()
conv_time = TimeConversion()
conv_wdir = WindDirectionConversion()
conv_wvel = WindVelocityConversion()
conv_conn = TextConversion({0:"cable", 3:"lost", 15:"wireless"})
conv_fore = TextConversion({0:"rainy", 1:"cloudy", 2:"sunny"})
conv_spdu = TextConversion({0:"m/s", 1:"knots", 2:"beaufort", 3:"km/h", 4:"mph"})
conv_tend = TextConversion({0:"steady", 1:"rising", 2:"falling"})
conv_wovr = TextConversion({0:"no", 1:"overflow"})
conv_wvld = TextConversion({0:"ok", 1:"invalid", 2:"overflow"})
conv_lcon = BinConversion("", 1, 0, "contrast")
conv_rec2 = BinConversion("", 2, 0, "record number")
conv_humi = BcdConversion("%", 2, 0, "humidity")
conv_pres = PressureConversion()
conv_rain = BcdConversion("mm", 6, 2, "rain")
conv_temp = BcdConversion("C", 4, 2, "temperature", -3000)
conv_per2 = BinConversion("s", 2, 1, "time interval", 5)
conv_per3 = BinConversion("min", 3, 0, "time interval")
conv_wspd = BinConversion("m/s", 3, 1, "speed")
conv_wind = WindConversion()
#
# Define a measurement on the Ws2300. This encapsulates:
# - The names (abbrev and long) of the thing being measured, eg wind speed.
# - The location it can be found at in the Ws2300's memory map.
# - The Conversion used to represent the figure.
#
class Measure(object):
IDS = {} # map, Measures defined. {id: Measure, ...}
NAMES = {} # map, Measures defined. {name: Measure, ...}
address = None # int, Nybble address in the Ws2300
conv = None # object, Type of value
id = None # string, Short name
name = None # string, Long name
reset = None # string, Id of measure used to reset this one
def __init__(self, address, id, conv, name, reset=None):
self.address = address
self.conv = conv
self.reset = reset
if id != None:
self.id = id
assert not id in self.__class__.IDS
self.__class__.IDS[id] = self
if name != None:
self.name = name
assert not name in self.__class__.NAMES
self.__class__.NAMES[name] = self
def __hash__(self):
return hash(self.id)
def __cmp__(self, other):
if isinstance(other, Measure):
return cmp(self.id, other.id)
return cmp(type(self), type(other))
#
# Conversion for raw Hex data. These are created as needed.
#
class HexConversion(Conversion):
def __init__(self, nybble_count):
Conversion.__init__(self, "", nybble_count, "hex data")
def binary2value(self, data):
return data
def value2binary(self, value):
return value
def str(self, value):
return ",".join(["%x" % nybble for nybble in value])
def parse(self, s):
toks = s.replace(","," ").split()
for i in range(len(toks)):
s = list(toks[i])
s.reverse()
toks[i] = ''.join(s)
list_str = list(''.join(toks))
self.nybble_count = len(list_str)
return tuple([int(nybble) for nybble in list_str])
#
# The raw nybble measure.
#
class HexMeasure(Measure):
def __init__(self, address, id, conv, name):
self.address = address
self.name = name
self.conv = conv
#
# A History record. Again a kludge to make history fit into the framework
# developed for the other measurements. History records are identified
# by their record number. Record number 0 is the most recently written
# record, record number 1 is the next most recently written and so on.
#
class HistoryMeasure(Measure):
HISTORY_BUFFER_ADDR = 0x6c6 # int, Address of the first history record
MAX_HISTORY_RECORDS = 0xaf # string, Max number of history records stored
LAST_POINTER = None # int, Pointer to last record
RECORD_COUNT = None # int, Number of records in use
recno = None # int, The record number this represents
conv = conv_hist
def __init__(self, recno):
self.recno = recno
def set_constants(cls, ws2300):
measures = [Measure.IDS["hp"], Measure.IDS["hn"]]
data = read_measurements(ws2300, measures)
cls.LAST_POINTER = int(measures[0].conv.binary2value(data[0]))
cls.RECORD_COUNT = int(measures[1].conv.binary2value(data[1]))
set_constants = classmethod(set_constants)
def id(self):
return "h%03d" % self.recno
id = property(id)
def name(self):
return "history record %d" % self.recno
name = property(name)
def offset(self):
if self.LAST_POINTER is None:
raise StandardError("HistoryMeasure.set_constants hasn't been called")
return (self.LAST_POINTER - self.recno) % self.MAX_HISTORY_RECORDS
offset = property(offset)
def address(self):
return self.HISTORY_BUFFER_ADDR + self.conv.nybble_count * self.offset
address = property(address)
#
# The measurements we know about. This is all of them documented in
# memory_map_2300.txt, bar the history. History is handled specially.
# And of course, the "c?"'s aren't real measures at all - its the current
# time on this machine.
#
Measure( -18, "ct", conv_time, "this computer's time")
Measure( -12, "cw", conv_utme, "this computer's date time")
Measure( -6, "cd", conv_date, "this computer's date")
Measure(0x006, "bz", conv_buzz, "buzzer")
Measure(0x00f, "wsu", conv_spdu, "wind speed units")
Measure(0x016, "lb", conv_lbck, "lcd backlight")
Measure(0x019, "sss", conv_als2, "storm warn alarm set")
Measure(0x019, "sts", conv_als0, "station time alarm set")
Measure(0x01a, "phs", conv_als3, "pressure max alarm set")
Measure(0x01a, "pls", conv_als2, "pressure min alarm set")
Measure(0x01b, "oths", conv_als3, "out temp max alarm set")
Measure(0x01b, "otls", conv_als2, "out temp min alarm set")
Measure(0x01b, "iths", conv_als1, "in temp max alarm set")
Measure(0x01b, "itls", conv_als0, "in temp min alarm set")
Measure(0x01c, "dphs", conv_als3, "dew point max alarm set")
Measure(0x01c, "dpls", conv_als2, "dew point min alarm set")
Measure(0x01c, "wchs", conv_als1, "wind chill max alarm set")
Measure(0x01c, "wcls", conv_als0, "wind chill min alarm set")
Measure(0x01d, "ihhs", conv_als3, "in humidity max alarm set")
Measure(0x01d, "ihls", conv_als2, "in humidity min alarm set")
Measure(0x01d, "ohhs", conv_als1, "out humidity max alarm set")
Measure(0x01d, "ohls", conv_als0, "out humidity min alarm set")
Measure(0x01e, "rhhs", conv_als1, "rain 1h alarm set")
Measure(0x01e, "rdhs", conv_als0, "rain 24h alarm set")
Measure(0x01f, "wds", conv_als2, "wind direction alarm set")
Measure(0x01f, "wshs", conv_als1, "wind speed max alarm set")
Measure(0x01f, "wsls", conv_als0, "wind speed min alarm set")
Measure(0x020, "siv", conv_ala2, "icon alarm active")
Measure(0x020, "stv", conv_ala0, "station time alarm active")
Measure(0x021, "phv", conv_ala3, "pressure max alarm active")
Measure(0x021, "plv", conv_ala2, "pressure min alarm active")
Measure(0x022, "othv", conv_ala3, "out temp max alarm active")
Measure(0x022, "otlv", conv_ala2, "out temp min alarm active")
Measure(0x022, "ithv", conv_ala1, "in temp max alarm active")
Measure(0x022, "itlv", conv_ala0, "in temp min alarm active")
Measure(0x023, "dphv", conv_ala3, "dew point max alarm active")
Measure(0x023, "dplv", conv_ala2, "dew point min alarm active")
Measure(0x023, "wchv", conv_ala1, "wind chill max alarm active")
Measure(0x023, "wclv", conv_ala0, "wind chill min alarm active")
Measure(0x024, "ihhv", conv_ala3, "in humidity max alarm active")
Measure(0x024, "ihlv", conv_ala2, "in humidity min alarm active")
Measure(0x024, "ohhv", conv_ala1, "out humidity max alarm active")
Measure(0x024, "ohlv", conv_ala0, "out humidity min alarm active")
Measure(0x025, "rhhv", conv_ala1, "rain 1h alarm active")
Measure(0x025, "rdhv", conv_ala0, "rain 24h alarm active")
Measure(0x026, "wdv", conv_ala2, "wind direction alarm active")
Measure(0x026, "wshv", conv_ala1, "wind speed max alarm active")
Measure(0x026, "wslv", conv_ala0, "wind speed min alarm active")
Measure(0x027, None, conv_ala3, "pressure max alarm active alias")
Measure(0x027, None, conv_ala2, "pressure min alarm active alias")
Measure(0x028, None, conv_ala3, "out temp max alarm active alias")
Measure(0x028, None, conv_ala2, "out temp min alarm active alias")
Measure(0x028, None, conv_ala1, "in temp max alarm active alias")
Measure(0x028, None, conv_ala0, "in temp min alarm active alias")
Measure(0x029, None, conv_ala3, "dew point max alarm active alias")
Measure(0x029, None, conv_ala2, "dew point min alarm active alias")
Measure(0x029, None, conv_ala1, "wind chill max alarm active alias")
Measure(0x029, None, conv_ala0, "wind chill min alarm active alias")
Measure(0x02a, None, conv_ala3, "in humidity max alarm active alias")
Measure(0x02a, None, conv_ala2, "in humidity min alarm active alias")
Measure(0x02a, None, conv_ala1, "out humidity max alarm active alias")
Measure(0x02a, None, conv_ala0, "out humidity min alarm active alias")
Measure(0x02b, None, conv_ala1, "rain 1h alarm active alias")
Measure(0x02b, None, conv_ala0, "rain 24h alarm active alias")
Measure(0x02c, None, conv_ala2, "wind direction alarm active alias")
Measure(0x02c, None, conv_ala2, "wind speed max alarm active alias")
Measure(0x02c, None, conv_ala2, "wind speed min alarm active alias")
Measure(0x200, "st", conv_time, "station set time", reset="ct")
Measure(0x23b, "sw", conv_dtme, "station current date time")
Measure(0x24d, "sd", conv_date, "station set date", reset="cd")
Measure(0x266, "lc", conv_lcon, "lcd contrast (ro)")
Measure(0x26b, "for", conv_fore, "forecast")
Measure(0x26c, "ten", conv_tend, "tendency")
Measure(0x346, "it", conv_temp, "in temp")
Measure(0x34b, "itl", conv_temp, "in temp min", reset="it")
Measure(0x350, "ith", conv_temp, "in temp max", reset="it")
Measure(0x354, "itlw", conv_stmp, "in temp min when", reset="sw")
Measure(0x35e, "ithw", conv_stmp, "in temp max when", reset="sw")
Measure(0x369, "itla", conv_temp, "in temp min alarm")
Measure(0x36e, "itha", conv_temp, "in temp max alarm")
Measure(0x373, "ot", conv_temp, "out temp")
Measure(0x378, "otl", conv_temp, "out temp min", reset="ot")
Measure(0x37d, "oth", conv_temp, "out temp max", reset="ot")
Measure(0x381, "otlw", conv_stmp, "out temp min when", reset="sw")
Measure(0x38b, "othw", conv_stmp, "out temp max when", reset="sw")
Measure(0x396, "otla", conv_temp, "out temp min alarm")
Measure(0x39b, "otha", conv_temp, "out temp max alarm")
Measure(0x3a0, "wc", conv_temp, "wind chill")
Measure(0x3a5, "wcl", conv_temp, "wind chill min", reset="wc")
Measure(0x3aa, "wch", conv_temp, "wind chill max", reset="wc")
Measure(0x3ae, "wclw", conv_stmp, "wind chill min when", reset="sw")
Measure(0x3b8, "wchw", conv_stmp, "wind chill max when", reset="sw")
Measure(0x3c3, "wcla", conv_temp, "wind chill min alarm")
Measure(0x3c8, "wcha", conv_temp, "wind chill max alarm")
Measure(0x3ce, "dp", conv_temp, "dew point")
Measure(0x3d3, "dpl", conv_temp, "dew point min", reset="dp")
Measure(0x3d8, "dph", conv_temp, "dew point max", reset="dp")
Measure(0x3dc, "dplw", conv_stmp, "dew point min when", reset="sw")
Measure(0x3e6, "dphw", conv_stmp, "dew point max when", reset="sw")
Measure(0x3f1, "dpla", conv_temp, "dew point min alarm")
Measure(0x3f6, "dpha", conv_temp, "dew point max alarm")
Measure(0x3fb, "ih", conv_humi, "in humidity")
Measure(0x3fd, "ihl", conv_humi, "in humidity min", reset="ih")
Measure(0x3ff, "ihh", conv_humi, "in humidity max", reset="ih")
Measure(0x401, "ihlw", conv_stmp, "in humidity min when", reset="sw")
Measure(0x40b, "ihhw", conv_stmp, "in humidity max when", reset="sw")
Measure(0x415, "ihla", conv_humi, "in humidity min alarm")
Measure(0x417, "ihha", conv_humi, "in humidity max alarm")
Measure(0x419, "oh", conv_humi, "out humidity")
Measure(0x41b, "ohl", conv_humi, "out humidity min", reset="oh")
Measure(0x41d, "ohh", conv_humi, "out humidity max", reset="oh")
Measure(0x41f, "ohlw", conv_stmp, "out humidity min when", reset="sw")
Measure(0x429, "ohhw", conv_stmp, "out humidity max when", reset="sw")
Measure(0x433, "ohla", conv_humi, "out humidity min alarm")
Measure(0x435, "ohha", conv_humi, "out humidity max alarm")
Measure(0x497, "rd", conv_rain, "rain 24h")
Measure(0x49d, "rdh", conv_rain, "rain 24h max", reset="rd")
Measure(0x4a3, "rdhw", conv_stmp, "rain 24h max when", reset="sw")
Measure(0x4ae, "rdha", conv_rain, "rain 24h max alarm")
Measure(0x4b4, "rh", conv_rain, "rain 1h")
Measure(0x4ba, "rhh", conv_rain, "rain 1h max", reset="rh")
Measure(0x4c0, "rhhw", conv_stmp, "rain 1h max when", reset="sw")
Measure(0x4cb, "rhha", conv_rain, "rain 1h max alarm")
Measure(0x4d2, "rt", conv_rain, "rain total", reset=0)
Measure(0x4d8, "rtrw", conv_stmp, "rain total reset when", reset="sw")
Measure(0x4ee, "wsl", conv_wspd, "wind speed min", reset="ws")
Measure(0x4f4, "wsh", conv_wspd, "wind speed max", reset="ws")
Measure(0x4f8, "wslw", conv_stmp, "wind speed min when", reset="sw")
Measure(0x502, "wshw", conv_stmp, "wind speed max when", reset="sw")
Measure(0x527, "wso", conv_wovr, "wind speed overflow")
Measure(0x528, "wsv", conv_wvld, "wind speed validity")
Measure(0x529, "wv", conv_wvel, "wind velocity")
Measure(0x529, "ws", conv_wspd, "wind speed")
Measure(0x52c, "w0", conv_wdir, "wind direction")
Measure(0x52d, "w1", conv_wdir, "wind direction 1")
Measure(0x52e, "w2", conv_wdir, "wind direction 2")
Measure(0x52f, "w3", conv_wdir, "wind direction 3")
Measure(0x530, "w4", conv_wdir, "wind direction 4")
Measure(0x531, "w5", conv_wdir, "wind direction 5")
Measure(0x533, "wsla", conv_wspd, "wind speed min alarm")
Measure(0x538, "wsha", conv_wspd, "wind speed max alarm")
Measure(0x54d, "cn", conv_conn, "connection type")
Measure(0x54f, "cc", conv_per2, "connection time till connect")
Measure(0x5d8, "pa", conv_pres, "pressure absolute")
Measure(0x5e2, "pr", conv_pres, "pressure relative")
Measure(0x5ec, "pc", conv_pres, "pressure correction")
Measure(0x5f6, "pal", conv_pres, "pressure absolute min", reset="pa")
Measure(0x600, "prl", conv_pres, "pressure relative min", reset="pr")
Measure(0x60a, "pah", conv_pres, "pressure absolute max", reset="pa")
Measure(0x614, "prh", conv_pres, "pressure relative max", reset="pr")
Measure(0x61e, "plw", conv_stmp, "pressure min when", reset="sw")
Measure(0x628, "phw", conv_stmp, "pressure max when", reset="sw")
Measure(0x63c, "pla", conv_pres, "pressure min alarm")
Measure(0x650, "pha", conv_pres, "pressure max alarm")
Measure(0x6b2, "hi", conv_per3, "history interval")
Measure(0x6b5, "hc", conv_per3, "history time till sample")
Measure(0x6b8, "hw", conv_stmp, "history last sample when")
Measure(0x6c2, "hp", conv_rec2, "history last record pointer",reset=0)
Measure(0x6c4, "hn", conv_rec2, "history number of records", reset=0)
# get all of the wind info in a single invocation
Measure(0x527, "wind", conv_wind, "wind")
#
# Read the requests.
#
def read_measurements(ws2300, read_requests):
if not read_requests:
return []
#
# Optimise what we have to read.
#
batches = [(m.address, m.conv.nybble_count) for m in read_requests]
batches.sort()
index = 1
addr = {batches[0][0]: 0}
while index < len(batches):
same_sign = (batches[index-1][0] < 0) == (batches[index][0] < 0)
same_area = batches[index-1][0] + batches[index-1][1] + 6 >= batches[index][0]
if not same_sign or not same_area:
addr[batches[index][0]] = index
index += 1
continue
addr[batches[index][0]] = index-1
batches[index-1] = batches[index-1][0], batches[index][0] + batches[index][1] - batches[index-1][0]
del batches[index]
#
# Read the data.
#
nybbles = ws2300.read_batch(batches)
#
# Return the data read in the order it was requested.
#
results = []
for measure in read_requests:
index = addr[measure.address]
offset = measure.address - batches[index][0]
results.append(nybbles[index][offset:offset+measure.conv.nybble_count])
return results
class WS23xxConfEditor(weewx.drivers.AbstractConfEditor):
@property
def default_stanza(self):
return """
[WS23xx]
# This section is for the La Crosse WS-2300 series of weather stations.
# Serial port such as /dev/ttyS0, /dev/ttyUSB0, or /dev/cuaU0
port = /dev/ttyUSB0
# The station model, e.g., 'LaCrosse WS2317' or 'TFA Primus'
model = LaCrosse WS23xx
# The driver to use:
driver = weewx.drivers.ws23xx
"""
def prompt_for_settings(self):
print "Specify the serial port on which the station is connected, for"
print "example /dev/ttyUSB0 or /dev/ttyS0."
port = self._prompt('port', '/dev/ttyUSB0')
return {'port': port}
# define a main entry point for basic testing of the station without weewx
# engine and service overhead. invoke this as follows from the weewx root dir:
#
# PYTHONPATH=bin python bin/weewx/drivers/ws23xx.py
if __name__ == '__main__':
import optparse
usage = """%prog [options] [--debug] [--help]"""
syslog.openlog('ws23xx', syslog.LOG_PID | syslog.LOG_CONS)
syslog.setlogmask(syslog.LOG_UPTO(syslog.LOG_INFO))
port = DEFAULT_PORT
parser = optparse.OptionParser(usage=usage)
parser.add_option('--version', dest='version', action='store_true',
help='display driver version')
parser.add_option('--debug', dest='debug', action='store_true',
help='display diagnostic information while running')
parser.add_option('--port', dest='port', metavar='PORT',
help='serial port to which the station is connected')
parser.add_option('--readings', dest='readings', action='store_true',
help='display sensor readings')
parser.add_option("--records", dest="records", type=int, metavar="N",
help="display N station records, oldest to newest")
parser.add_option('--help-measures', dest='hm', action='store_true',
help='display measure names')
parser.add_option('--measure', dest='measure', type=str,
metavar="MEASURE", help='display single measure')
(options, args) = parser.parse_args()
if options.version:
print "ws23xx driver version %s" % DRIVER_VERSION
exit(1)
if options.debug is not None:
syslog.setlogmask(syslog.LOG_UPTO(syslog.LOG_DEBUG))
if options.port:
port = options.port
with WS23xx(port) as s:
if options.readings:
data = s.get_raw_data(SENSOR_IDS)
print data
if options.records is not None:
for ts,record in s.gen_records(count=options.records):
print ts,record
if options.measure:
data = s.get_raw_data([options.measure])
print data
if options.hm:
for m in Measure.IDS:
print "%s\t%s" % (m, Measure.IDS[m].name)
| knnniggett/weewx | bin/weewx/drivers/ws23xx.py | Python | gpl-3.0 | 77,294 | 0.004463 |
from __future__ import unicode_literals
import logging
import os
import string
import urllib
import urlparse
import glib
logger = logging.getLogger(__name__)
XDG_DIRS = {
'XDG_CACHE_DIR': glib.get_user_cache_dir(),
'XDG_CONFIG_DIR': glib.get_user_config_dir(),
'XDG_DATA_DIR': glib.get_user_data_dir(),
'XDG_MUSIC_DIR': glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC),
}
# XDG_MUSIC_DIR can be none, so filter out any bad data.
XDG_DIRS = dict((k, v) for k, v in XDG_DIRS.items() if v is not None)
def get_or_create_dir(dir_path):
if not isinstance(dir_path, bytes):
raise ValueError('Path is not a bytestring.')
dir_path = expand_path(dir_path)
if os.path.isfile(dir_path):
raise OSError(
'A file with the same name as the desired dir, '
'"%s", already exists.' % dir_path)
elif not os.path.isdir(dir_path):
logger.info('Creating dir %s', dir_path)
os.makedirs(dir_path, 0755)
return dir_path
def get_or_create_file(file_path, mkdir=True, content=None):
if not isinstance(file_path, bytes):
raise ValueError('Path is not a bytestring.')
file_path = expand_path(file_path)
if mkdir:
get_or_create_dir(os.path.dirname(file_path))
if not os.path.isfile(file_path):
logger.info('Creating file %s', file_path)
with open(file_path, 'w') as fh:
if content:
fh.write(content)
return file_path
def path_to_uri(path):
"""
Convert OS specific path to file:// URI.
Accepts either unicode strings or bytestrings. The encoding of any
bytestring will be maintained so that :func:`uri_to_path` can return the
same bytestring.
Returns a file:// URI as an unicode string.
"""
if isinstance(path, unicode):
path = path.encode('utf-8')
path = urllib.quote(path)
return urlparse.urlunsplit((b'file', b'', path, b'', b''))
def uri_to_path(uri):
"""
Convert an URI to a OS specific path.
Returns a bytestring, since the file path can contain chars with other
encoding than UTF-8.
If we had returned these paths as unicode strings, you wouldn't be able to
look up the matching dir or file on your file system because the exact path
would be lost by ignoring its encoding.
"""
if isinstance(uri, unicode):
uri = uri.encode('utf-8')
return urllib.unquote(urlparse.urlsplit(uri).path)
def split_path(path):
parts = []
while True:
path, part = os.path.split(path)
if part:
parts.insert(0, part)
if not path or path == b'/':
break
return parts
def expand_path(path):
# TODO: document as we want people to use this.
if not isinstance(path, bytes):
raise ValueError('Path is not a bytestring.')
try:
path = string.Template(path).substitute(XDG_DIRS)
except KeyError:
return None
path = os.path.expanduser(path)
path = os.path.abspath(path)
return path
def find_files(path):
"""
Finds all files within a path.
Directories and files with names starting with ``.`` is ignored.
:returns: yields the full path to files as bytestrings
"""
if isinstance(path, unicode):
path = path.encode('utf-8')
if os.path.isfile(path):
return
for dirpath, dirnames, filenames in os.walk(path, followlinks=True):
for dirname in dirnames:
if dirname.startswith(b'.'):
# Skip hidden dirs by modifying dirnames inplace
dirnames.remove(dirname)
for filename in filenames:
if filename.startswith(b'.'):
# Skip hidden files
continue
yield os.path.relpath(os.path.join(dirpath, filename), path)
def check_file_path_is_inside_base_dir(file_path, base_path):
assert not file_path.endswith(os.sep), (
'File path %s cannot end with a path separator' % file_path)
# Expand symlinks
real_base_path = os.path.realpath(base_path)
real_file_path = os.path.realpath(file_path)
# Use dir of file for prefix comparision, so we don't accept
# /tmp/foo.m3u as being inside /tmp/foo, simply because they have a
# common prefix, /tmp/foo, which matches the base path, /tmp/foo.
real_dir_path = os.path.dirname(real_file_path)
# Check if dir of file is the base path or a subdir
common_prefix = os.path.commonprefix([real_base_path, real_dir_path])
assert common_prefix == real_base_path, (
'File path %s must be in %s' % (real_file_path, real_base_path))
# FIXME replace with mock usage in tests.
class Mtime(object):
def __init__(self):
self.fake = None
def __call__(self, path):
if self.fake is not None:
return self.fake
return int(os.stat(path).st_mtime)
def set_fake_time(self, time):
self.fake = time
def undo_fake(self):
self.fake = None
mtime = Mtime()
| abarisain/mopidy | mopidy/utils/path.py | Python | apache-2.0 | 5,006 | 0.0002 |
def First_Part(orbits):
Orbits = dict()
checksum = 0
for orbit in orbits:
od, og = orbit.split(')')
Orbits[og] = od
for og in Orbits.keys():
while 1:
try:
og = Orbits[og]
checksum += 1
except KeyError:
break
return checksum
def Second_Part(orbits):
Orbits = dict()
for orbit in orbits:
od, og = orbit.split(')')
Orbits[og] = od
oPast = ["YOU"]
oCurr = [Orbits["YOU"]]
oNext = list()
dist = 0
while "SAN" not in oCurr:
for o in oCurr:
oNext += ([Orbits[o]] if o != "COM" else []) + [i for i in Orbits.keys() if Orbits[i] == o and i not in oPast]
oCurr = oNext
oNext = list()
oPast += oCurr
dist += 1
return dist - 1
Orbits = '''COM)B
B)C
C)D
D)E
E)F
B)G
G)H
D)I
E)J
J)K
K)L
K)YOU
I)SAN'''.split('\n')
Orbits = open("Inputs/Day_06.txt", 'r').read().split('\n')[:-1]
print(First_Part(Orbits))
print(Second_Part(Orbits))
| ImpregnableProgrammer/Advent-of-Code | 2019/Day_06.py | Python | gpl-3.0 | 1,071 | 0.006536 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# author: J.Y Han
# start
# spawn-fcgi -d /users/hanjiyun/project/geeksoho -f /users/hanjiyun/project/geeksoho/application.py -a 127.0.0.1 -p 9001
#stop
# kill `pgrep -f "/users/hanjiyun/project/geeksoho/application.py"`
import os
import web
import rediswebpy
from web.contrib.template import render_jinja
import misc
db = web.database(dbn='mysql', db='geeksoho', user='geeksoho', passwd='geeksoho')
urls = (
'/', 'index',
'/test', 'test'
)
# controllers
# ===============
class index:
"""Home"""
def GET(self):
# return pjax('jobs.html')
jobsList = GetJobs()
return render.jobs(jobsList=jobsList)
def POST(self):
data = web.input(title='', link='', company='', company_weibo='', company_website='', city='', salary='', intro='')
CreatNewJob(data)
raise web.seeother('/')
class test:
"""test"""
def GET(self):
# return pjax('test.html')
return render.test()
# models
# =============
def CreatNewJob(data):
db.insert(
'jobs',
title = data.title,
link = data.link,
company = data.company,
company_weibo = data.company_weibo,
company_website = data.company_website,
city = data.city,
salary = data.salary,
intro = data.intro)
def GetJobs():
return db.select('jobs', limit = 100, order='id DESC')
# globals = get_all_functions(misc)
app = web.application(urls, globals())
web.config.debug = True
cache = False
session = web.session.Session(app, rediswebpy.RedisStore(), initializer={'count': 0})
render = render_jinja(
'templates', # 设置模板路径.
encoding = 'utf-8', # 编码.
)
myFilters = {'filter_tags': misc.filter_tags,}
render._lookup.filters.update(myFilters)
if __name__ == "__main__":
web.wsgi.runwsgi = lambda func, addr=None: web.wsgi.runfcgi(func, addr)
app.run() | naoyeye/geeksoho | application.py | Python | mit | 1,969 | 0.019457 |
from __future__ import with_statement
from ofxclient.account import Account
from configparser import ConfigParser
import os
import os.path
try:
import keyring
KEYRING_AVAILABLE = True
except:
KEYRING_AVAILABLE = False
try:
DEFAULT_CONFIG = os.path.expanduser(os.path.join('~', 'ofxclient.ini'))
except:
DEFAULT_CONFIG = None
class SecurableConfigParser(ConfigParser):
""":py:class:`ConfigParser.ConfigParser` subclass that knows how to store
options marked as secure into the OS specific
keyring/keychain.
To mark an option as secure, the caller must call
'set_secure' at least one time for the particular
option and from then on it will be seen as secure
and will be stored / retrieved from the keychain.
Example::
from ofxclient.config import SecurableConfigParser
# password will not be saved in the config file
c = SecurableConfigParser()
c.add_section('Info')
c.set('Info','username','bill')
c.set_secure('Info','password','s3cre7')
with open('config.ini','w') as fp:
c.write(fp)
"""
_secure_placeholder = '%{secured}'
def __init__(self, keyring_name='ofxclient',
keyring_available=KEYRING_AVAILABLE, **kwargs):
ConfigParser.__init__(self, interpolation = None)
self.keyring_name = keyring_name
self.keyring_available = keyring_available
self._unsaved = {}
self.keyring_name = keyring_name
def is_secure_option(self, section, option):
"""Test an option to see if it is secured or not.
:param section: section id
:type section: string
:param option: option name
:type option: string
:rtype: boolean
otherwise.
"""
if not self.has_section(section):
return False
if not self.has_option(section, option):
return False
if ConfigParser.get(self, section, option) == self._secure_placeholder:
return True
return False
def has_secure_option(self, section, option):
"""See is_secure_option"""
return self.is_secure_option(section, option)
def items(self, section):
"""Get all items for a section. Subclassed, to ensure secure
items come back with the unencrypted data.
:param section: section id
:type section: string
"""
items = []
for k, v in ConfigParser.items(self, section):
if self.is_secure_option(section, k):
v = self.get(section, k)
items.append((k, v))
return items
def secure_items(self, section):
"""Like items() but only return secure items.
:param section: section id
:type section: string
"""
return [x
for x in self.items(section)
if self.is_secure_option(section, x[0])]
def set(self, section, option, value):
"""Set an option value. Knows how to set options properly marked
as secure."""
if self.is_secure_option(section, option):
self.set_secure(section, option, value)
else:
ConfigParser.set(self, section, option, value)
def set_secure(self, section, option, value):
"""Set an option and mark it as secure.
Any subsequent uses of 'set' or 'get' will also
now know that this option is secure as well.
"""
if self.keyring_available:
s_option = "%s%s" % (section, option)
self._unsaved[s_option] = ('set', value)
value = self._secure_placeholder
ConfigParser.set(self, section, option, value)
def get(self, section, option, *args):
"""Get option value from section. If an option is secure,
populates the plain text."""
if self.is_secure_option(section, option) and self.keyring_available:
s_option = "%s%s" % (section, option)
if self._unsaved.get(s_option, [''])[0] == 'set':
return self._unsaved[s_option][1]
else:
return keyring.get_password(self.keyring_name, s_option)
return ConfigParser.get(self, section, option, *args)
def remove_option(self, section, option):
"""Removes the option from ConfigParser as well as
the secure storage backend
"""
if self.is_secure_option(section, option) and self.keyring_available:
s_option = "%s%s" % (section, option)
self._unsaved[s_option] = ('delete', None)
ConfigParser.remove_option(self, section, option)
def write(self, *args):
"""See ConfigParser.write(). Also writes secure items to keystore."""
ConfigParser.write(self, *args)
if self.keyring_available:
for key, thing in self._unsaved.items():
action = thing[0]
value = thing[1]
if action == 'set':
keyring.set_password(self.keyring_name, key, value)
elif action == 'delete':
try:
keyring.delete_password(self.keyring_name, key)
except:
pass
self._unsaved = {}
class OfxConfig(object):
"""Default config file handler for other tools to use.
This can read and write from the default config which is
$USERS_HOME/ofxclient.ini
:param file_name: absolute path to a config file (optional)
:type file_name: string or None
Example usage::
from ofxclient.config import OfxConfig
from ofxclient import Account
a = Account()
c = OfxConfig(file_name='/tmp/new.ini')
c.add_account(a)
c.save()
account_list = c.accounts()
one_account = c.account( a.local_id() )
"""
def __init__(self, file_name=None):
self.secured_field_names = [
'institution.username',
'institution.password'
]
f = file_name or DEFAULT_CONFIG
if f is None:
raise ValueError('file_name is required')
self._load(f)
def reload(self):
"""Reload the config file from disk"""
return self._load()
def accounts(self):
"""List of confgured :py:class:`ofxclient.Account` objects"""
return [self._section_to_account(s)
for s in self.parser.sections()]
def encrypted_accounts(self):
return [a
for a in self.accounts()
if self.is_encrypted_account(a.local_id())]
def unencrypted_accounts(self):
return [a
for a in self.accounts()
if not self.is_encrypted_account(a.local_id())]
def account(self, id):
"""Get :py:class:`ofxclient.Account` by section id"""
if self.parser.has_section(id):
return self._section_to_account(id)
return None
def add_account(self, account):
"""Add Account to config (does not save)"""
serialized = account.serialize()
section_items = flatten_dict(serialized)
section_id = section_items['local_id']
if not self.parser.has_section(section_id):
self.parser.add_section(section_id)
for key in sorted(section_items):
self.parser.set(section_id, key, section_items[key])
self.encrypt_account(id=section_id)
return self
def encrypt_account(self, id):
"""Make sure that certain fields are encrypted."""
for key in self.secured_field_names:
value = self.parser.get(id, key)
self.parser.set_secure(id, key, value)
return self
def is_encrypted_account(self, id):
"""Are all fields for the account id encrypted?"""
for key in self.secured_field_names:
if not self.parser.is_secure_option(id, key):
return False
return True
def remove_account(self, id):
"""Add Account from config (does not save)"""
if self.parser.has_section(id):
self.parser.remove_section(id)
return True
return False
def save(self):
"""Save changes to config file"""
with open(self.file_name, 'w') as fp:
self.parser.write(fp)
return self
def _load(self, file_name=None):
self.parser = None
file_name = file_name or self.file_name
if not os.path.exists(file_name):
with open(file_name, 'a'):
os.utime(file_name, None)
self.file_name = file_name
conf = SecurableConfigParser()
conf.readfp(open(self.file_name))
self.parser = conf
return self
def _section_to_account(self, section):
section_items = dict(self.parser.items(section))
serialized = unflatten_dict(section_items)
return Account.deserialize(serialized)
def unflatten_dict(dict, prefix=None, separator='.'):
ret = {}
for k, v in dict.items():
key_parts = k.split(separator)
if len(key_parts) == 1:
ret[k] = v
else:
first = key_parts[0]
rest = key_parts[1:]
temp = ret.setdefault(first, {})
for idx, part in enumerate(rest):
if (idx+1) == len(rest):
temp[part] = v
else:
temp = temp.setdefault(part, {})
return ret
def flatten_dict(dict_, prefix=None, separator='.'):
ret = {}
for k, v in dict_.items():
if prefix:
flat_key = separator.join([prefix, k])
else:
flat_key = k
if isinstance(v, dict):
deflated = flatten_dict(v, prefix=flat_key)
for dk, dv in deflated.items():
ret[dk] = dv
else:
ret[flat_key] = v
return ret
| jbms/ofxclient | ofxclient/config.py | Python | mit | 9,882 | 0.000506 |
# --------------------------------------------------------------------------
#
# Copyright (c) Microsoft Corporation. All rights reserved.
#
# The MIT License (MIT)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the ""Software""), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#
# --------------------------------------------------------------------------
import unittest
import subprocess
import sys
import isodate
import tempfile
import json
from uuid import uuid4
from datetime import date, datetime, timedelta
import os
from os.path import dirname, pardir, join, realpath, sep, pardir
cwd = dirname(realpath(__file__))
root = realpath(join(cwd , pardir, pardir, pardir, pardir, pardir))
sys.path.append(join(root, "ClientRuntimes" , "Python", "msrest"))
sys.path.append(join(root, "ClientRuntimes" , "Python", "msrestazure"))
log_level = int(os.environ.get('PythonLogLevel', 30))
tests = realpath(join(cwd, pardir, "Expected", "AcceptanceTests"))
sys.path.append(join(tests, "Paging"))
from msrest.serialization import Deserializer
from msrest.exceptions import DeserializationError
from msrestazure.azure_exceptions import CloudError
from msrest.authentication import BasicTokenAuthentication
from autorestpagingtestservice import AutoRestPagingTestService
from autorestpagingtestservice.models import PagingGetMultiplePagesWithOffsetOptions
class PagingTests(unittest.TestCase):
def setUp(self):
cred = BasicTokenAuthentication({"access_token" :str(uuid4())})
self.client = AutoRestPagingTestService(cred, base_url="http://localhost:3000")
self.client._client._adapter.add_hook("request", self.client._client._adapter._test_pipeline)
return super(PagingTests, self).setUp()
def test_paging_happy_path(self):
pages = self.client.paging.get_single_pages()
items = [i for i in pages]
self.assertIsNone(pages.next_link)
self.assertEqual(len(items), 1)
self.assertEqual(items[0].properties.id, 1)
self.assertEqual(items[0].properties.name, "Product")
pages = self.client.paging.get_multiple_pages()
self.assertIsNotNone(pages.next_link)
items = [i for i in pages]
self.assertIsNone(pages.next_link)
self.assertEqual(len(items), 10)
pages.reset()
more_items = [i for i in pages]
eq = [e for e in items if e not in more_items]
self.assertEqual(len(eq), 0)
with self.assertRaises(GeneratorExit):
pages.next()
pages = self.client.paging.get_multiple_pages_retry_first()
self.assertIsNotNone(pages.next_link)
items = [i for i in pages]
self.assertIsNone(pages.next_link)
self.assertEqual(len(items), 10)
pages = self.client.paging.get_multiple_pages_retry_second()
self.assertIsNotNone(pages.next_link)
items = [i for i in pages]
self.assertIsNone(pages.next_link)
self.assertEqual(len(items), 10)
pages = self.client.paging.get_single_pages(raw=True)
items = [i for i in pages]
self.assertIsNone(pages.next_link)
self.assertEqual(len(items), 1)
self.assertEqual(items, pages.raw.output)
pages = self.client.paging.get_multiple_pages(raw=True)
self.assertIsNotNone(pages.next_link)
items = [i for i in pages]
self.assertEqual(len(items), 10)
self.assertIsNotNone(pages.raw.response)
options = PagingGetMultiplePagesWithOffsetOptions(100)
pages = self.client.paging.get_multiple_pages_with_offset(paging_get_multiple_pages_with_offset_options=options)
self.assertIsNotNone(pages.next_link)
items = [i for i in pages]
self.assertEqual(len(items), 10)
self.assertEqual(items[-1].properties.id, 110)
pages = self.client.paging.get_multiple_pages_retry_first(raw=True)
self.assertIsNotNone(pages.next_link)
items = [i for i in pages]
self.assertEqual(len(items), 10)
pages = self.client.paging.get_multiple_pages_retry_second(raw=True)
self.assertIsNotNone(pages.next_link)
items = [i for i in pages]
self.assertEqual(len(items), 10)
def test_paging_sad_path(self):
pages = self.client.paging.get_single_pages_failure()
with self.assertRaises(CloudError):
items = [i for i in pages]
pages = self.client.paging.get_multiple_pages_failure()
self.assertIsNotNone(pages.next_link)
with self.assertRaises(CloudError):
items = [i for i in pages]
pages = self.client.paging.get_multiple_pages_failure_uri()
with self.assertRaises(ValueError):
items = [i for i in pages]
pages = self.client.paging.get_single_pages_failure(raw=True)
with self.assertRaises(CloudError):
items = [i for i in pages]
pages = self.client.paging.get_multiple_pages_failure(raw=True)
self.assertIsNotNone(pages.next_link)
with self.assertRaises(CloudError):
items = [i for i in pages]
pages = self.client.paging.get_multiple_pages_failure_uri(raw=True)
with self.assertRaises(ValueError):
items = [i for i in pages]
if __name__ == '__main__':
unittest.main()
| sharadagarwal/autorest | AutoRest/Generators/Python/Azure.Python.Tests/AcceptanceTests/paging_tests.py | Python | mit | 6,270 | 0.003191 |
import os
from threading import RLock
from path import Path
import mtt.config as base_config # noqa
__all__ = ['config', 'lock']
class ConfigAccessor:
def __init__(self, configuration_items):
self.config = configuration_items
def update(self, other):
self.config.update(other.config if 'config' in other else other)
def __getattr__(self, item):
if item in self.config:
return self.config[item]
raise AttributeError(f'Unknown configuration option \'{item}\'')
def __getitem__(self, item):
try:
return self.config[item]
except KeyError:
raise KeyError(f'Unknown configuration option \'{item}\'')
def get_variables_in_module(module_name: str) -> ConfigAccessor:
module = globals().get(module_name, None)
module_type = type(os)
class_type = type(Path)
variables = {}
if module:
variables = {key: value for key, value in module.__dict__.items()
if not (key.startswith('__') or key.startswith('_'))
and not isinstance(value, module_type)
and not isinstance(value, class_type)}
return ConfigAccessor(variables)
config = get_variables_in_module('base_config')
try:
import mtt.user_config as user_config # noqa
config.update(get_variables_in_module('user_config'))
except ImportError:
pass
lock = RLock()
| halcy/MastodonToTwitter | mtt/__init__.py | Python | mit | 1,421 | 0 |
import unittest
from integration.thrift.test_thrift import ThriftTestCase
from scales.thriftmux import ThriftMux
class ThriftMuxTestCase(ThriftTestCase):
BUILDER = ThriftMux
if __name__ == '__main__':
unittest.main()
| steveniemitz/scales | test/integration/thrift/test_mux.py | Python | mit | 224 | 0.017857 |
from mediadrop.lib.auth.group_based_policy import *
| kgao/MediaDrop | mediacore/lib/auth/group_based_policy.py | Python | gpl-3.0 | 52 | 0 |
import os
from queue import Queue
from bears.python.requirements.PySafetyBear import PySafetyBear
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting
from coalib.testing.LocalBearTestHelper import LocalBearTestHelper
from coalib.results.Result import Result
from coalib.results.RESULT_SEVERITY import RESULT_SEVERITY
from coalib.testing.BearTestHelper import generate_skip_decorator
def get_testfile_path(name):
return os.path.join(os.path.dirname(__file__),
'PySafety_test_files',
name)
def load_testfile(name):
return open(get_testfile_path(name)).readlines()
@generate_skip_decorator(PySafetyBear)
class PySafetyBearTest(LocalBearTestHelper):
def setUp(self):
self.section = Section('name')
self.uut = PySafetyBear(self.section, Queue())
def test_without_vulnerability(self):
self.check_validity(self.uut, ['lxml==3.6.0'])
def test_with_vulnerability(self):
self.check_invalidity(self.uut, ['bottle==0.10.1'])
def test_with_cve_vulnerability(self):
file_name = 'requirement.txt'
file_contents = load_testfile(file_name)
file_contents = [file_contents[0]]
self.check_results(
self.uut,
file_contents,
[Result.from_values('PySafetyBear',
'bottle<0.12.10 is vulnerable '
'to CVE-2016-9964 and your project '
'is using 0.10.0.',
file=get_testfile_path(file_name),
line=1,
column=9,
end_line=1,
end_column=15,
severity=RESULT_SEVERITY.NORMAL,
additional_info='redirect() in bottle.py '
'in bottle 0.12.10 doesn\'t filter '
'a "\\r\\n" sequence, which leads '
'to a CRLF attack, as demonstrated '
'by a redirect("233\\r\\nSet-Cookie: '
'name=salt") call.'),
Result.from_values('PySafetyBear',
'bottle>=0.10,<0.10.12 is vulnerable to '
'CVE-2014-3137 and your project is '
'using 0.10.0.',
file=get_testfile_path(file_name),
line=1,
column=9,
end_line=1,
end_column=15,
severity=RESULT_SEVERITY.NORMAL,
additional_info='Bottle 0.10.x before 0.10.12,'
' 0.11.x before 0.11.7, and 0.12.x before'
' 0.12.6 does not properly limit content'
' types, which allows remote attackers to'
' bypass intended access restrictions via an'
' accepted Content-Type followed by a ;'
' (semi-colon) and a Content-Type that'
' would not be accepted, as demonstrated in'
' YouCompleteMe to execute arbitrary code.')],
filename=get_testfile_path(file_name))
def test_without_cve_vulnerability(self):
file_name = 'requirement.txt'
file_contents = load_testfile(file_name)
file_contents = [file_contents[1]]
self.check_results(
self.uut,
file_contents,
[Result.from_values('PySafetyBear',
'locustio<0.7 is vulnerable to pyup.io-25878 '
'and your project is using 0.5.1.',
file=get_testfile_path(file_name),
line=1,
column=11,
end_line=1,
end_column=16,
severity=RESULT_SEVERITY.NORMAL,
additional_info='locustio before '
'0.7 uses pickle.',
)],
filename=get_testfile_path(file_name))
def test_with_cve_ignore(self):
self.section.append(Setting('cve_ignore', 'CVE-2016-9964, '
'CVE-2014-3137'))
file_name = 'requirement.txt'
file_contents = load_testfile(file_name)
# file_contents = [file_contents[0]]
self.check_results(
self.uut,
file_contents,
[Result.from_values('PySafetyBear',
'locustio<0.7 is vulnerable to pyup.io-25878 '
'and your project is using 0.5.1.',
file=get_testfile_path(file_name),
line=2,
column=11,
end_line=2,
end_column=16,
severity=RESULT_SEVERITY.NORMAL,
additional_info='locustio before '
'0.7 uses pickle.',
)],
filename=get_testfile_path(file_name))
def test_with_no_requirements(self):
self.check_validity(self.uut, [])
def test_with_no_pinned_requirements(self):
self.check_validity(self.uut, ['foo'])
| coala/coala-bears | tests/python/requirements/PySafetyBearWithoutMockTest.py | Python | agpl-3.0 | 5,749 | 0 |
import datetime
import uuid
from flask import current_app as app
from flask import url_for
from database import db
from sqlalchemy import Column, DateTime, String, Text
from sqlalchemy.dialects.postgresql import UUID
class Poster(db.Model):
__tablename__ = 'posters'
id = Column(UUID(as_uuid=True), primary_key=True)
title = Column(String(400), nullable=False, default='Untitled')
authors = Column(Text)
abstract = Column(Text)
source_url = Column(String(400), nullable=False)
download_url = Column(String(400), nullable=False)
presented_at = Column(String(200))
created_at = Column('create_date', DateTime, default=datetime.datetime.now())
id_admin = Column(UUID(as_uuid=True), unique=True, nullable=False)
email = Column(String(50))
def __init__(self, title, source_url, download_url, authors=None,
abstract=None, presented_at=None):
self.id = uuid.uuid4()
self.title = title
self.authors = authors
self.abstract = abstract
self.source_url = source_url
self.download_url = download_url
self.presented_at = presented_at
self.id_admin = uuid.uuid4()
def __repr__(self):
return '<User {}>'.format(str(self.id))
def serialize(self):
return {
'id': self.id,
'title': self.title,
'authors': self.authors,
'abstract': self.abstract,
'source_url': self.source_url,
'download_url': self.download_url,
'presented_at': self.presented_at,
'created_at': self.created_at.isoformat(),
'thumbnail_url': self.thumbnail_url(),
}
def public_url(self, absolute=False):
return url_for('get_poster', id=self.id, _external=absolute)
def admin_url(self, absolute=False):
return url_for('edit_poster', id_admin=self.id_admin, _external=absolute)
def qrcode_svg_url(self, absolute=False):
return url_for('get_qrcode_svg', id=self.id, _external=absolute)
def qrcode_png_url(self, absolute=False):
return url_for('get_qrcode_png', id=self.id, _external=absolute)
def is_image(self):
return self.download_url.endswith('.png') or self.download_url.endswith('.jpg')
def viewable_download_url(self):
cloudinary = app.config['CLOUDINARY_BASE_URL']
if self.is_image() or self.download_url.startswith(cloudinary):
return self.download_url
return '{}/image/fetch/{}'.format(cloudinary, self.download_url)
def thumbnail_url(self):
cloudinary = app.config['CLOUDINARY_BASE_URL']
transformations = 'c_thumb,w_370,h_200,f_png'
if self.download_url.startswith(cloudinary):
return self.download_url.replace('/upload/', '/upload/{}/'.format(transformations))
return '{}/image/fetch/{}/{}'.format(cloudinary, transformations, self.download_url)
| TailorDev/pauling | api/models.py | Python | mit | 2,935 | 0.001704 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright (c) 2013, 2014, Pyhrol, pyhrol@rambler.ru
# GEO: N55.703431,E37.623324 .. N48.742359,E44.536997
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# 4. Neither the name of the Pyhrol 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 REGENTS 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 REGENTS OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
#
import example_0050
try:
example_0050.function_with_keywords()
except TypeError as ex:
print '***', ex
try:
example_0050.function_with_keywords(arg1 = 1)
except TypeError as ex:
print '***', ex
example_0050.function_with_keywords(counter = 1, description = "One")
example_0050.function_with_keywords(description = "Two", counter = 2)
| dyomas/pyhrol | examples/example_0050.py | Python | bsd-3-clause | 1,983 | 0.00706 |
#!/usr/bin/env python
#
# fdaemon.py
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307 USA
#
# Author: Tarun Kumar <reach.tarun.here AT gmail.com>
# NOTE: THIS IS AN INITIAL RELEASE AND IS LIKELY TO BE UNSTABLE
import ConfigParser
import logging
import os
import time
from django.core.management.base import BaseCommand, CommandError
from interface.models import *
from django.core import serializers
import pymongo
import gridfs
from bson import ObjectId
from bson.json_util import loads,dumps
import json
from bson import json_util
from interface.producer import Producer
import pika
STATUS_NEW = 0 # identifies local status of task
STATUS_PROCESSING = 1
STATUS_FAILED = 2
STATUS_COMPLETED = 3
STATUS_TIMEOUT = 4
NEW_SCAN_TASK = 1 # identifies data being sent to back end
SEND_ANY = 'Any'
ANY_QUEUE = 'any_queue'
PRIVATE_QUEUE = 'private_queue'
RPC_PORT = 5672
config = ConfigParser.ConfigParser()
config.read(os.path.join(settings.BASE_DIR, "conf", "backend.conf"))
BACKEND_HOST = config.get('backend', 'host', 'localhost')
# mongodb connection settings
client = pymongo.MongoClient()
db = client.thug
dbfs = client.thugfs
fs = gridfs.GridFS(dbfs)
logger = logging.getLogger(__name__)
class Command(BaseCommand):
active_scans = [] # List of started threads waiting for a result to be returned from backend otr timeout
def fetch_new_tasks(self):
return Task.objects.filter(status__exact=STATUS_NEW).order_by('submitted_on')
def fetch_pending_tasks(self):
return Task.objects.filter(status__exact=STATUS_PROCESSING)
# Task.objects.filter(status__exact=STATUS_PROCESSING).update(status=STATUS_NEW)
def mark_as_running(self, task):
logger.debug("[{}] Marking task as running".format(task.id))
task.started_on = datetime.now(pytz.timezone(settings.TIME_ZONE))
task.status = STATUS_PROCESSING
task.save()
def mark_as_failed(self, task):
logger.debug("[{}] Marking task as failed".format(task.id))
task.completed_on = datetime.now(pytz.timezone(settings.TIME_ZONE))
task.status = STATUS_FAILED
task.save()
def mark_as_timeout(self, task):
logger.debug("[{}] Marking task timeout".format(task.id))
task.completed_on = datetime.now(pytz.timezone(settings.TIME_ZONE))
task.status = STATUS_TIMEOUT
task.save()
def mark_as_completed(self, task):
logger.debug("[{}] Marking task as completed".format(task.id))
task.completed_on = datetime.now(pytz.timezone(settings.TIME_ZONE))
task.status = STATUS_COMPLETED
task.save()
def renderTaskDetail(self, pkval):
return dumps(
loads(
serializers.serialize(
'json',
[Task.objects.get(pk=pkval), ]
)
)[0]
)
def post_new_task(self, task):
temp1 = loads(self.renderTaskDetail(task.id))
temp = temp1['fields']
backend = temp.pop("backend")
temp.pop("user")
temp.pop("sharing_model")
temp.pop("plugin_status")
temp.pop("sharing_groups")
temp.pop("star")
temp["frontend_id"] = temp1.pop("pk")
temp["task"] = NEW_SCAN_TASK
logger.debug("Posting task {}".format(temp["frontend_id"]))
if backend == SEND_ANY:
# start the thread to post the scan on any queue
scan = Producer(json.dumps(temp),
BACKEND_HOST,
RPC_PORT,
ANY_QUEUE,
temp["frontend_id"])
scan.start()
self.active_scans.append(scan)
self.mark_as_running(task)
else:
# start the thread to post the scan on private queue
scan = Producer(json.dumps(temp),
backend,
RPC_PORT,
PRIVATE_QUEUE,
temp["frontend_id"])
scan.start()
self.active_scans.append(scan)
self.mark_as_running(task)
def search_samples_dict_list(self, search_id,sample_dict):
# returns new gridfs sample_id
for x in sample_dict:
if x["_id"] == search_id:
return x["sample_id"]
def retrieve_save_document(self, response, files):
# now files for locations
for x in response["locations"]:
if x['content_id'] is not None:
dfile = [
item["data"] for item in files
if str(item["content_id"]) == x["content_id"]
][0]
new_fs_id = str(fs.put(dfile.encode('utf-8')))
# now change id in repsonse
x['location_id'] = new_fs_id
# now for samples
for x in response["samples"]:
dfile = [
item["data"] for item in files
if str(item["sample_id"]) == x["sample_id"]
][0]
new_fs_id = str(fs.put(dfile.encode('utf-8')))
# now change id in repsonse
x['sample_id'] = new_fs_id
# same for pcaps
for x in response["pcaps"]:
if x['content_id'] is not None:
dfile = [
item["data"] for item in files
if str(item["content_id"]) == x["content_id"]
][0]
new_fs_id = str(fs.put(dfile.encode('utf-8')))
# now change id in repsonse
x['content_id'] = new_fs_id
# for vt,andro etc. eoint sample_id to gridfs id
# check for issues in this
for x in response["virustotal"]:
x['sample_id'] = self.search_samples_dict_list(x['sample_id'],
response["samples"])
for x in response["honeyagent"]:
x['sample_id'] = self.search_samples_dict_list(x['sample_id'],
response["samples"])
for x in response["androguard"]:
x['sample_id'] = self.search_samples_dict_list(x['sample_id'],
response["samples"])
for x in response["peepdf"]:
x['sample_id'] = self.search_samples_dict_list(x['sample_id'],
response["samples"])
# remove id from all samples and pcaps
for x in response["samples"]:
x.pop("_id")
response.pop("_id")
frontend_analysis_id = db.analysiscombo.insert(response)
return frontend_analysis_id
def process_response(self, task):
analysis = json.loads(task.response, object_hook=decoder)
if analysis["status"] is STATUS_COMPLETED:
logger.info("Task Completed")
analysis_response = analysis["data"]
files = json_util.loads(analysis["files"])
local_task = Task.objects.get(id=analysis_response["frontend_id"])
frontend_analysis_id = self.retrieve_save_document(analysis_response,
files)
local_task.object_id = frontend_analysis_id
local_task.save()
self.mark_as_completed(local_task)
self.active_scans.remove(task)
else:
logger.info("Task Failed")
local_scan = Task.objects.get(id=analysis["data"])
self.mark_as_failed(local_scan)
self.active_scans.remove(task)
def handle(self, *args, **options):
logger.debug("Starting up frontend daemon")
while True:
logger.debug("Fetching new tasks to post to backend.")
tasks = self.fetch_new_tasks()
logger.debug("Got {} new tasks".format(len(tasks)))
for task in tasks:
self.post_new_task(task)
logger.debug("Checking for complete tasks")
for task in self.active_scans:
if task.thread_exception is None:
if hasattr(task, 'response') and task.response is not None:
self.process_response(task)
else:
if task.thread_exception == pika.exceptions.ConnectionClosed:
logger.info("Cannot make connection to backend via {} {} {}".format(task.host,
task.port,
task.routing_key))
self.mark_as_failed(Task.objects.filter(pk=int(task.frontend_id))[0])
self.active_scans.remove(task)
if task.thread_exception == pika.exceptions.ProbableAuthenticationError or \
task.thread_exception == pika.exceptions.ProbableAccessDeniedError:
logger.info("Task {} Authentication Error".format(int(task.frontend_id)))
self.mark_as_failed(Task.objects.filter(pk=int(task.frontend_id))[0])
self.active_scans.remove(task)
if task.thread_exception == TimeOutException:
logger.info("Task {} took too long to reply".format(int(task.frontend_id)))
self.mark_as_timeout(Task.objects.filter(pk=int(task.frontend_id))[0])
self.active_scans.remove(task)
logger.debug("Sleeping for {} seconds".format(6))
time.sleep(6)
| Dennisparchkov/rumal | interface/management/commands/fdaemon.py | Python | gpl-2.0 | 10,312 | 0.001649 |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('hhlregistrations', '0004_auto_20150411_1935'),
]
operations = [
migrations.AddField(
model_name='event',
name='payment_due',
field=models.DateTimeField(null=True, blank=True),
),
migrations.AddField(
model_name='event',
name='require_registration',
field=models.BooleanField(default=False),
),
]
| hacklab-fi/hhlevents | hhlevents/apps/hhlregistrations/migrations/0005_auto_20150412_1806.py | Python | bsd-3-clause | 592 | 0 |
#!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2011 thomasv@gitorious
#
# 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/>.
# Note: The deserialization code originally comes from ABE.
import bitcoin
from bitcoin import *
from util import print_error
import time
import struct
#
# Workalike python implementation of Bitcoin's CDataStream class.
#
import struct
import StringIO
import mmap
import random
NO_SIGNATURE = 'ff'
class SerializationError(Exception):
""" Thrown when there's a problem deserializing or serializing """
class BCDataStream(object):
def __init__(self):
self.input = None
self.read_cursor = 0
def clear(self):
self.input = None
self.read_cursor = 0
def write(self, bytes): # Initialize with string of bytes
if self.input is None:
self.input = bytes
else:
self.input += bytes
def map_file(self, file, start): # Initialize with bytes from file
self.input = mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ)
self.read_cursor = start
def seek_file(self, position):
self.read_cursor = position
def close_file(self):
self.input.close()
def read_string(self):
# Strings are encoded depending on length:
# 0 to 252 : 1-byte-length followed by bytes (if any)
# 253 to 65,535 : byte'253' 2-byte-length followed by bytes
# 65,536 to 4,294,967,295 : byte '254' 4-byte-length followed by bytes
# ... and the Bitcoin client is coded to understand:
# greater than 4,294,967,295 : byte '255' 8-byte-length followed by bytes of string
# ... but I don't think it actually handles any strings that big.
if self.input is None:
raise SerializationError("call write(bytes) before trying to deserialize")
try:
length = self.read_compact_size()
except IndexError:
raise SerializationError("attempt to read past end of buffer")
return self.read_bytes(length)
def write_string(self, string):
# Length-encoded as with read-string
self.write_compact_size(len(string))
self.write(string)
def read_bytes(self, length):
try:
result = self.input[self.read_cursor:self.read_cursor+length]
self.read_cursor += length
return result
except IndexError:
raise SerializationError("attempt to read past end of buffer")
return ''
def read_boolean(self): return self.read_bytes(1)[0] != chr(0)
def read_int16(self): return self._read_num('<h')
def read_uint16(self): return self._read_num('<H')
def read_int32(self): return self._read_num('<i')
def read_uint32(self): return self._read_num('<I')
def read_int64(self): return self._read_num('<q')
def read_uint64(self): return self._read_num('<Q')
def write_boolean(self, val): return self.write(chr(1) if val else chr(0))
def write_int16(self, val): return self._write_num('<h', val)
def write_uint16(self, val): return self._write_num('<H', val)
def write_int32(self, val): return self._write_num('<i', val)
def write_uint32(self, val): return self._write_num('<I', val)
def write_int64(self, val): return self._write_num('<q', val)
def write_uint64(self, val): return self._write_num('<Q', val)
def read_compact_size(self):
size = ord(self.input[self.read_cursor])
self.read_cursor += 1
if size == 253:
size = self._read_num('<H')
elif size == 254:
size = self._read_num('<I')
elif size == 255:
size = self._read_num('<Q')
return size
def write_compact_size(self, size):
if size < 0:
raise SerializationError("attempt to write size < 0")
elif size < 253:
self.write(chr(size))
elif size < 2**16:
self.write('\xfd')
self._write_num('<H', size)
elif size < 2**32:
self.write('\xfe')
self._write_num('<I', size)
elif size < 2**64:
self.write('\xff')
self._write_num('<Q', size)
def _read_num(self, format):
(i,) = struct.unpack_from(format, self.input, self.read_cursor)
self.read_cursor += struct.calcsize(format)
return i
def _write_num(self, format, num):
s = struct.pack(format, num)
self.write(s)
#
# enum-like type
# From the Python Cookbook, downloaded from http://code.activestate.com/recipes/67107/
#
import types, string, exceptions
class EnumException(exceptions.Exception):
pass
class Enumeration:
def __init__(self, name, enumList):
self.__doc__ = name
lookup = { }
reverseLookup = { }
i = 0
uniqueNames = [ ]
uniqueValues = [ ]
for x in enumList:
if type(x) == types.TupleType:
x, i = x
if type(x) != types.StringType:
raise EnumException, "enum name is not a string: " + x
if type(i) != types.IntType:
raise EnumException, "enum value is not an integer: " + i
if x in uniqueNames:
raise EnumException, "enum name is not unique: " + x
if i in uniqueValues:
raise EnumException, "enum value is not unique for " + x
uniqueNames.append(x)
uniqueValues.append(i)
lookup[x] = i
reverseLookup[i] = x
i = i + 1
self.lookup = lookup
self.reverseLookup = reverseLookup
def __getattr__(self, attr):
if not self.lookup.has_key(attr):
raise AttributeError
return self.lookup[attr]
def whatis(self, value):
return self.reverseLookup[value]
# This function comes from bitcointools, bct-LICENSE.txt.
def long_hex(bytes):
return bytes.encode('hex_codec')
# This function comes from bitcointools, bct-LICENSE.txt.
def short_hex(bytes):
t = bytes.encode('hex_codec')
if len(t) < 11:
return t
return t[0:4]+"..."+t[-4:]
def parse_redeemScript(bytes):
dec = [ x for x in script_GetOp(bytes.decode('hex')) ]
# 2 of 2
match = [ opcodes.OP_2, opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4, opcodes.OP_2, opcodes.OP_CHECKMULTISIG ]
if match_decoded(dec, match):
pubkeys = [ dec[1][1].encode('hex'), dec[2][1].encode('hex') ]
return 2, pubkeys
# 2 of 3
match = [ opcodes.OP_2, opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4, opcodes.OP_3, opcodes.OP_CHECKMULTISIG ]
if match_decoded(dec, match):
pubkeys = [ dec[1][1].encode('hex'), dec[2][1].encode('hex'), dec[3][1].encode('hex') ]
return 2, pubkeys
opcodes = Enumeration("Opcodes", [
("OP_0", 0), ("OP_PUSHDATA1",76), "OP_PUSHDATA2", "OP_PUSHDATA4", "OP_1NEGATE", "OP_RESERVED",
"OP_1", "OP_2", "OP_3", "OP_4", "OP_5", "OP_6", "OP_7",
"OP_8", "OP_9", "OP_10", "OP_11", "OP_12", "OP_13", "OP_14", "OP_15", "OP_16",
"OP_NOP", "OP_VER", "OP_IF", "OP_NOTIF", "OP_VERIF", "OP_VERNOTIF", "OP_ELSE", "OP_ENDIF", "OP_VERIFY",
"OP_RETURN", "OP_TOALTSTACK", "OP_FROMALTSTACK", "OP_2DROP", "OP_2DUP", "OP_3DUP", "OP_2OVER", "OP_2ROT", "OP_2SWAP",
"OP_IFDUP", "OP_DEPTH", "OP_DROP", "OP_DUP", "OP_NIP", "OP_OVER", "OP_PICK", "OP_ROLL", "OP_ROT",
"OP_SWAP", "OP_TUCK", "OP_CAT", "OP_SUBSTR", "OP_LEFT", "OP_RIGHT", "OP_SIZE", "OP_INVERT", "OP_AND",
"OP_OR", "OP_XOR", "OP_EQUAL", "OP_EQUALVERIFY", "OP_RESERVED1", "OP_RESERVED2", "OP_1ADD", "OP_1SUB", "OP_2MUL",
"OP_2DIV", "OP_NEGATE", "OP_ABS", "OP_NOT", "OP_0NOTEQUAL", "OP_ADD", "OP_SUB", "OP_MUL", "OP_DIV",
"OP_MOD", "OP_LSHIFT", "OP_RSHIFT", "OP_BOOLAND", "OP_BOOLOR",
"OP_NUMEQUAL", "OP_NUMEQUALVERIFY", "OP_NUMNOTEQUAL", "OP_LESSTHAN",
"OP_GREATERTHAN", "OP_LESSTHANOREQUAL", "OP_GREATERTHANOREQUAL", "OP_MIN", "OP_MAX",
"OP_WITHIN", "OP_RIPEMD160", "OP_SHA1", "OP_SHA256", "OP_HASH160",
"OP_HASH256", "OP_CODESEPARATOR", "OP_CHECKSIG", "OP_CHECKSIGVERIFY", "OP_CHECKMULTISIG",
"OP_CHECKMULTISIGVERIFY",
("OP_SINGLEBYTE_END", 0xF0),
("OP_DOUBLEBYTE_BEGIN", 0xF000),
"OP_PUBKEY", "OP_PUBKEYHASH",
("OP_INVALIDOPCODE", 0xFFFF),
])
def script_GetOp(bytes):
i = 0
while i < len(bytes):
vch = None
opcode = ord(bytes[i])
i += 1
if opcode >= opcodes.OP_SINGLEBYTE_END:
opcode <<= 8
opcode |= ord(bytes[i])
i += 1
if opcode <= opcodes.OP_PUSHDATA4:
nSize = opcode
if opcode == opcodes.OP_PUSHDATA1:
nSize = ord(bytes[i])
i += 1
elif opcode == opcodes.OP_PUSHDATA2:
(nSize,) = struct.unpack_from('<H', bytes, i)
i += 2
elif opcode == opcodes.OP_PUSHDATA4:
(nSize,) = struct.unpack_from('<I', bytes, i)
i += 4
vch = bytes[i:i+nSize]
i += nSize
yield (opcode, vch, i)
def script_GetOpName(opcode):
return (opcodes.whatis(opcode)).replace("OP_", "")
def decode_script(bytes):
result = ''
for (opcode, vch, i) in script_GetOp(bytes):
if len(result) > 0: result += " "
if opcode <= opcodes.OP_PUSHDATA4:
result += "%d:"%(opcode,)
result += short_hex(vch)
else:
result += script_GetOpName(opcode)
return result
def match_decoded(decoded, to_match):
if len(decoded) != len(to_match):
return False;
for i in range(len(decoded)):
if to_match[i] == opcodes.OP_PUSHDATA4 and decoded[i][0] <= opcodes.OP_PUSHDATA4 and decoded[i][0]>0:
continue # Opcodes below OP_PUSHDATA4 all just push data onto stack, and are equivalent.
if to_match[i] != decoded[i][0]:
return False
return True
def parse_sig(x_sig):
s = []
for sig in x_sig:
if sig[-2:] == '01':
s.append(sig[:-2])
else:
assert sig == NO_SIGNATURE
s.append(None)
return s
def is_extended_pubkey(x_pubkey):
return x_pubkey[0:2] in ['fe', 'ff']
def x_to_xpub(x_pubkey):
if x_pubkey[0:2] == 'ff':
from account import BIP32_Account
xpub, s = BIP32_Account.parse_xpubkey(x_pubkey)
return xpub
def parse_xpub(x_pubkey):
if x_pubkey[0:2] == 'ff':
from account import BIP32_Account
xpub, s = BIP32_Account.parse_xpubkey(x_pubkey)
pubkey = BIP32_Account.derive_pubkey_from_xpub(xpub, s[0], s[1])
elif x_pubkey[0:2] == 'fe':
from account import OldAccount
mpk, s = OldAccount.parse_xpubkey(x_pubkey)
pubkey = OldAccount.get_pubkey_from_mpk(mpk.decode('hex'), s[0], s[1])
else:
pubkey = x_pubkey
return pubkey
def parse_scriptSig(d, bytes):
try:
decoded = [ x for x in script_GetOp(bytes) ]
except Exception:
# coinbase transactions raise an exception
print_error("cannot find address in input script", bytes.encode('hex'))
return
# payto_pubkey
match = [ opcodes.OP_PUSHDATA4 ]
if match_decoded(decoded, match):
sig = decoded[0][1].encode('hex')
d['address'] = "(pubkey)"
d['signatures'] = [sig]
d['num_sig'] = 1
d['x_pubkeys'] = ["(pubkey)"]
d['pubkeys'] = ["(pubkey)"]
return
# non-generated TxIn transactions push a signature
# (seventy-something bytes) and then their public key
# (65 bytes) onto the stack:
match = [ opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4 ]
if match_decoded(decoded, match):
sig = decoded[0][1].encode('hex')
x_pubkey = decoded[1][1].encode('hex')
try:
signatures = parse_sig([sig])
pubkey = parse_xpub(x_pubkey)
except:
import traceback
traceback.print_exc(file=sys.stdout)
print_error("cannot find address in input script", bytes.encode('hex'))
return
d['signatures'] = signatures
d['x_pubkeys'] = [x_pubkey]
d['num_sig'] = 1
d['pubkeys'] = [pubkey]
d['address'] = public_key_to_bc_address(pubkey.decode('hex'))
return
# p2sh transaction, 2 of n
match = [ opcodes.OP_0 ]
while len(match) < len(decoded):
match.append(opcodes.OP_PUSHDATA4)
if not match_decoded(decoded, match):
print_error("cannot find address in input script", bytes.encode('hex'))
return
x_sig = map(lambda x:x[1].encode('hex'), decoded[1:-1])
d['signatures'] = parse_sig(x_sig)
d['num_sig'] = 2
dec2 = [ x for x in script_GetOp(decoded[-1][1]) ]
match_2of2 = [ opcodes.OP_2, opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4, opcodes.OP_2, opcodes.OP_CHECKMULTISIG ]
match_2of3 = [ opcodes.OP_2, opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4, opcodes.OP_PUSHDATA4, opcodes.OP_3, opcodes.OP_CHECKMULTISIG ]
if match_decoded(dec2, match_2of2):
x_pubkeys = [ dec2[1][1].encode('hex'), dec2[2][1].encode('hex') ]
elif match_decoded(dec2, match_2of3):
x_pubkeys = [ dec2[1][1].encode('hex'), dec2[2][1].encode('hex'), dec2[3][1].encode('hex') ]
else:
print_error("cannot find address in input script", bytes.encode('hex'))
return
d['x_pubkeys'] = x_pubkeys
pubkeys = map(parse_xpub, x_pubkeys)
d['pubkeys'] = pubkeys
redeemScript = Transaction.multisig_script(pubkeys,2)
d['redeemScript'] = redeemScript
d['address'] = hash_160_to_bc_address(hash_160(redeemScript.decode('hex')), 9)
def get_address_from_output_script(bytes):
decoded = [ x for x in script_GetOp(bytes) ]
# The Genesis Block, self-payments, and pay-by-IP-address payments look like:
# 65 BYTES:... CHECKSIG
match = [ opcodes.OP_PUSHDATA4, opcodes.OP_CHECKSIG ]
if match_decoded(decoded, match):
return 'pubkey', decoded[0][1].encode('hex')
# Pay-by-Bitcoin-address TxOuts look like:
# DUP HASH160 20 BYTES:... EQUALVERIFY CHECKSIG
match = [ opcodes.OP_DUP, opcodes.OP_HASH160, opcodes.OP_PUSHDATA4, opcodes.OP_EQUALVERIFY, opcodes.OP_CHECKSIG ]
if match_decoded(decoded, match):
return 'address', hash_160_to_bc_address(decoded[2][1])
# p2sh
match = [ opcodes.OP_HASH160, opcodes.OP_PUSHDATA4, opcodes.OP_EQUAL ]
if match_decoded(decoded, match):
return 'address', hash_160_to_bc_address(decoded[1][1],9)
# OP_RETURN
match = [ opcodes.OP_RETURN, opcodes.OP_PUSHDATA4 ]
if match_decoded(decoded, match):
return 'op_return', decoded[1][1]
return "(None)", "(None)"
def parse_input(vds):
d = {}
prevout_hash = hash_encode(vds.read_bytes(32))
prevout_n = vds.read_uint32()
d['scriptSig'] = scriptSig = vds.read_bytes(vds.read_compact_size())
sequence = vds.read_uint32()
if prevout_hash == '00'*32:
d['is_coinbase'] = True
else:
d['is_coinbase'] = False
d['prevout_hash'] = prevout_hash
d['prevout_n'] = prevout_n
d['sequence'] = sequence
d['pubkeys'] = []
d['signatures'] = {}
d['address'] = None
if scriptSig:
parse_scriptSig(d, scriptSig)
return d
def parse_output(vds, i):
d = {}
d['value'] = vds.read_int64()
scriptPubKey = vds.read_bytes(vds.read_compact_size())
type, address = get_address_from_output_script(scriptPubKey)
d['type'] = type
d['address'] = address
d['scriptPubKey'] = scriptPubKey.encode('hex')
d['prevout_n'] = i
return d
def deserialize(raw):
vds = BCDataStream()
vds.write(raw.decode('hex'))
d = {}
start = vds.read_cursor
d['version'] = vds.read_int32()
n_vin = vds.read_compact_size()
d['inputs'] = []
for i in xrange(n_vin):
d['inputs'].append(parse_input(vds))
n_vout = vds.read_compact_size()
d['outputs'] = []
for i in xrange(n_vout):
d['outputs'].append(parse_output(vds, i))
d['lockTime'] = vds.read_uint32()
return d
push_script = lambda x: op_push(len(x)/2) + x
class Transaction:
def __str__(self):
if self.raw is None:
self.raw = self.serialize()
return self.raw
def __init__(self, inputs, outputs, locktime=0):
self.inputs = inputs
self.outputs = outputs
self.locktime = locktime
self.raw = None
@classmethod
def deserialize(klass, raw):
self = klass([],[])
self.update(raw)
return self
def update(self, raw):
d = deserialize(raw)
self.raw = raw
self.inputs = d['inputs']
self.outputs = map(lambda x: (x['type'], x['address'], x['value']), d['outputs'])
self.locktime = d['lockTime']
@classmethod
def sweep(klass, privkeys, network, to_address, fee):
inputs = []
for privkey in privkeys:
pubkey = public_key_from_private_key(privkey)
address = address_from_private_key(privkey)
u = network.synchronous_get([ ('blockchain.address.listunspent',[address])])[0]
pay_script = klass.pay_script('address', address)
for item in u:
item['scriptPubKey'] = pay_script
item['redeemPubkey'] = pubkey
item['address'] = address
item['prevout_hash'] = item['tx_hash']
item['prevout_n'] = item['tx_pos']
item['pubkeys'] = [pubkey]
item['x_pubkeys'] = [None]
item['signatures'] = [None]
item['num_sig'] = 1
inputs += u
if not inputs:
return
total = sum( map(lambda x:int(x.get('value')), inputs) ) - fee
outputs = [('address', to_address, total)]
self = klass(inputs, outputs)
self.sign({ pubkey:privkey })
return self
@classmethod
def multisig_script(klass, public_keys, num=None):
n = len(public_keys)
if num is None: num = n
# supports only "2 of 2", and "2 of 3" transactions
assert num <= n and n in [2,3]
if num==2:
s = '52'
elif num == 3:
s = '53'
else:
raise
for k in public_keys:
s += op_push(len(k)/2)
s += k
if n==2:
s += '52'
elif n==3:
s += '53'
else:
raise
s += 'ae'
return s
@classmethod
def pay_script(self, type, addr):
if type == 'op_return':
h = addr.encode('hex')
return '6a' + push_script(h)
else:
assert type == 'address'
addrtype, hash_160 = bc_address_to_hash_160(addr)
if addrtype == 50:
script = '76a9' # op_dup, op_hash_160
script += push_script(hash_160.encode('hex'))
script += '88ac' # op_equalverify, op_checksig
elif addrtype == 9:
script = 'a9' # op_hash_160
script += push_script(hash_160.encode('hex'))
script += '87' # op_equal
else:
raise
return script
def serialize(self, for_sig=None):
# for_sig:
# -1 : do not sign, estimate length
# i>=0 : sign input i
# None : add all signatures
inputs = self.inputs
outputs = self.outputs
s = int_to_hex(1,4) # version
s += var_int( len(inputs) ) # number of inputs
for i in range(len(inputs)):
txin = inputs[i]
s += txin['prevout_hash'].decode('hex')[::-1].encode('hex') # prev hash
s += int_to_hex(txin['prevout_n'],4) # prev index
p2sh = txin.get('redeemScript') is not None
num_sig = txin['num_sig']
address = txin['address']
x_signatures = txin['signatures']
signatures = filter(lambda x: x is not None, x_signatures)
is_complete = len(signatures) == num_sig
if for_sig in [-1, None]:
# if we have enough signatures, we use the actual pubkeys
# use extended pubkeys (with bip32 derivation)
sig_list = []
if for_sig == -1:
# we assume that signature will be 0x48 bytes long
pubkeys = txin['pubkeys']
sig_list = [ "00"* 0x48 ] * num_sig
elif is_complete:
pubkeys = txin['pubkeys']
for signature in signatures:
sig_list.append(signature + '01')
else:
pubkeys = txin['x_pubkeys']
for signature in x_signatures:
sig_list.append((signature + '01') if signature is not None else NO_SIGNATURE)
sig_list = ''.join( map( lambda x: push_script(x), sig_list))
if not p2sh:
script = sig_list
script += push_script(pubkeys[0])
else:
script = '00' # op_0
script += sig_list
redeem_script = self.multisig_script(pubkeys,2)
script += push_script(redeem_script)
elif for_sig==i:
script = txin['redeemScript'] if p2sh else self.pay_script('address', address)
else:
script = ''
s += var_int( len(script)/2 ) # script length
s += script
s += "ffffffff" # sequence
s += var_int( len(outputs) ) # number of outputs
for output in outputs:
type, addr, amount = output
s += int_to_hex( amount, 8) # amount
script = self.pay_script(type, addr)
s += var_int( len(script)/2 ) # script length
s += script # script
s += int_to_hex(0,4) # lock time
if for_sig is not None and for_sig != -1:
s += int_to_hex(1, 4) # hash type
return s
def tx_for_sig(self,i):
return self.serialize(for_sig = i)
def hash(self):
return Hash(self.raw.decode('hex') )[::-1].encode('hex')
def add_signature(self, i, pubkey, sig):
print_error("adding signature for", pubkey)
txin = self.inputs[i]
pubkeys = txin['pubkeys']
ii = pubkeys.index(pubkey)
txin['signatures'][ii] = sig
txin['x_pubkeys'][ii] = pubkey
self.inputs[i] = txin
self.raw = self.serialize()
def add_input(self, input):
self.inputs.append(input)
self.raw = None
def input_value(self):
return sum([x['value'] for x in self.inputs])
def output_value(self):
return sum([ x[2] for x in self.outputs])
def get_fee(self):
return self.input_value() - self.output_value()
def signature_count(self):
r = 0
s = 0
for txin in self.inputs:
if txin.get('is_coinbase'):
continue
signatures = filter(lambda x: x is not None, txin['signatures'])
s += len(signatures)
r += txin['num_sig']
return s, r
def is_complete(self):
s, r = self.signature_count()
return r == s
def inputs_to_sign(self):
from account import BIP32_Account, OldAccount
xpub_list = []
addr_list = set()
for txin in self.inputs:
x_signatures = txin['signatures']
signatures = filter(lambda x: x is not None, x_signatures)
if len(signatures) == txin['num_sig']:
# input is complete
continue
for k, x_pubkey in enumerate(txin['x_pubkeys']):
if x_signatures[k] is not None:
# this pubkey already signed
continue
if x_pubkey[0:2] == 'ff':
xpub, sequence = BIP32_Account.parse_xpubkey(x_pubkey)
xpub_list.append((xpub,sequence))
elif x_pubkey[0:2] == 'fe':
xpub, sequence = OldAccount.parse_xpubkey(x_pubkey)
xpub_list.append((xpub,sequence))
else:
addr_list.add(txin['address'])
return addr_list, xpub_list
def sign(self, keypairs):
print_error("tx.sign(), keypairs:", keypairs)
for i, txin in enumerate(self.inputs):
# continue if this txin is complete
signatures = filter(lambda x: x is not None, txin['signatures'])
num = txin['num_sig']
if len(signatures) == num:
continue
redeem_pubkeys = txin['pubkeys']
for_sig = Hash(self.tx_for_sig(i).decode('hex'))
for pubkey in redeem_pubkeys:
if pubkey in keypairs.keys():
# add signature
sec = keypairs[pubkey]
pkey = regenerate_key(sec)
secexp = pkey.secret
private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
public_key = private_key.get_verifying_key()
sig = private_key.sign_digest_deterministic( for_sig, hashfunc=hashlib.sha256, sigencode = ecdsa.util.sigencode_der )
assert public_key.verify_digest( sig, for_sig, sigdecode = ecdsa.util.sigdecode_der)
self.add_signature(i, pubkey, sig.encode('hex'))
print_error("is_complete", self.is_complete())
self.raw = self.serialize()
def add_pubkey_addresses(self, txlist):
for i in self.inputs:
if i.get("address") == "(pubkey)":
prev_tx = txlist.get(i.get('prevout_hash'))
if prev_tx:
address, value = prev_tx.get_outputs()[i.get('prevout_n')]
print_error("found pay-to-pubkey address:", address)
i["address"] = address
def get_outputs(self):
"""convert pubkeys to addresses"""
o = []
for type, x, v in self.outputs:
if type == 'address':
addr = x
elif type == 'pubkey':
addr = public_key_to_bc_address(x.decode('hex'))
elif type == 'op_return':
try:
addr = 'OP_RETURN: "' + x.decode('utf8') + '"'
except:
addr = 'OP_RETURN: "' + x.encode('hex') + '"'
else:
addr = "(None)"
o.append((addr,v))
return o
def get_output_addresses(self):
return map(lambda x:x[0], self.get_outputs())
def has_address(self, addr):
found = False
for txin in self.inputs:
if addr == txin.get('address'):
found = True
break
if addr in self.get_output_addresses():
found = True
return found
def get_value(self, addresses, prevout_values):
# return the balance for that tx
is_relevant = False
is_send = False
is_pruned = False
is_partial = False
v_in = v_out = v_out_mine = 0
for item in self.inputs:
addr = item.get('address')
if addr in addresses:
is_send = True
is_relevant = True
key = item['prevout_hash'] + ':%d'%item['prevout_n']
value = prevout_values.get( key )
if value is None:
is_pruned = True
else:
v_in += value
else:
is_partial = True
if not is_send: is_partial = False
for addr, value in self.get_outputs():
v_out += value
if addr in addresses:
v_out_mine += value
is_relevant = True
if is_pruned:
# some inputs are mine:
fee = None
if is_send:
v = v_out_mine - v_out
else:
# no input is mine
v = v_out_mine
else:
v = v_out_mine - v_in
if is_partial:
# some inputs are mine, but not all
fee = None
is_send = v < 0
else:
# all inputs are mine
fee = v_out - v_in
return is_relevant, is_send, v, fee
def as_dict(self):
import json
out = {
"hex":str(self),
"complete":self.is_complete()
}
return out
def required_fee(self, verifier):
# see https://en.bitcoin.it/wiki/Transaction_fees
threshold = 57600000*4
size = len(self.serialize(-1))/2
fee = 0
for o in self.get_outputs():
value = o[1]
if value < DUST_SOFT_LIMIT:
fee += MIN_RELAY_TX_FEE
sum = 0
for i in self.inputs:
age = verifier.get_confirmations(i["prevout_hash"])[0]
sum += i["value"] * age
priority = sum / size
print_error(priority, threshold)
if size < 5000 and fee == 0 and priority > threshold:
return 0
fee += (1 + size / 1000) * MIN_RELAY_TX_FEE
print_error(fee)
return fee
| wozz/electrum-myr | lib/transaction.py | Python | gpl-3.0 | 30,650 | 0.006754 |
from django.apps import AppConfig
class DocenteConfig(AppConfig):
name = 'docente'
| Bleno/sisgestor-django | docente/apps.py | Python | mit | 89 | 0 |
import unittest
import json
from privacyidea.app import create_app
from privacyidea.models import db
from privacyidea.lib.resolver import (save_resolver)
from privacyidea.lib.realm import (set_realm)
from privacyidea.lib.user import User
from privacyidea.lib.auth import create_db_admin
from privacyidea.api.lib.postpolicy import DEFAULT_POLICY_TEMPLATE_URL
PWFILE = "tests/testdata/passwords"
class FakeFlaskG():
policy_object = None
class MyTestCase(unittest.TestCase):
resolvername1 = "resolver1"
resolvername2 = "Resolver2"
resolvername3 = "reso3"
realm1 = "realm1"
realm2 = "realm2"
serials = ["SE1", "SE2", "SE3"]
otpkey = "3132333435363738393031323334353637383930"
@classmethod
def setUpClass(cls):
cls.app = create_app('testing', "")
cls.app_context = cls.app.app_context()
cls.app_context.push()
db.create_all()
# Create an admin for tests.
create_db_admin(cls.app, "testadmin", "admin@test.tld", "testpw")
def setUp_user_realms(self):
# create user realm
rid = save_resolver({"resolver": self.resolvername1,
"type": "passwdresolver",
"fileName": PWFILE})
self.assertTrue(rid > 0, rid)
(added, failed) = set_realm(self.realm1,
[self.resolvername1])
self.assertTrue(len(failed) == 0)
self.assertTrue(len(added) == 1)
user = User(login="root",
realm=self.realm1,
resolver=self.resolvername1)
user_str = "%s" % user
self.assertTrue(user_str == "<root.resolver1@realm1>", user_str)
self.assertFalse(user.is_empty())
self.assertTrue(User().is_empty())
user_repr = "%r" % user
expected = "User(login='root', realm='realm1', resolver='resolver1')"
self.assertTrue(user_repr == expected, user_repr)
def setUp_user_realm2(self):
# create user realm
rid = save_resolver({"resolver": self.resolvername1,
"type": "passwdresolver",
"fileName": PWFILE})
self.assertTrue(rid > 0, rid)
(added, failed) = set_realm(self.realm2,
[self.resolvername1])
self.assertTrue(len(failed) == 0)
self.assertTrue(len(added) == 1)
user = User(login="root",
realm=self.realm2,
resolver=self.resolvername1)
user_str = "%s" % user
self.assertTrue(user_str == "<root.resolver1@realm2>", user_str)
self.assertFalse(user.is_empty())
self.assertTrue(User().is_empty())
user_repr = "%r" % user
expected = "User(login='root', realm='realm2', resolver='resolver1')"
self.assertTrue(user_repr == expected, user_repr)
@classmethod
def tearDownClass(cls):
db.session.remove()
db.drop_all()
cls.app_context.pop()
def setUp(self):
self.authenticate()
def authenticate(self):
with self.app.test_request_context('/auth',
data={"username": "testadmin",
"password": "testpw"},
method='POST'):
res = self.app.full_dispatch_request()
self.assertTrue(res.status_code == 200, res)
result = json.loads(res.data).get("result")
self.assertTrue(result.get("status"), res.data)
self.at = result.get("value").get("token")
def authenticate_selfserive_user(self):
with self.app.test_request_context('/auth',
method='POST',
data={"username":
"selfservice@realm1",
"password": "test"}):
res = self.app.full_dispatch_request()
self.assertTrue(res.status_code == 200, res)
result = json.loads(res.data).get("result")
self.assertTrue(result.get("status"), res.data)
# In self.at_user we store the user token
self.at_user = result.get("value").get("token")
# check that this is a user
role = result.get("value").get("role")
self.assertTrue(role == "user", result)
self.assertEqual(result.get("value").get("realm"), "realm1")
# Test logout time
self.assertEqual(result.get("value").get("logout_time"), 120)
self.assertEqual(result.get("value").get("policy_template_url"),
DEFAULT_POLICY_TEMPLATE_URL)
| woddx/privacyidea | tests/base.py | Python | agpl-3.0 | 4,803 | 0.000625 |
#------------------------------------------------------------------------------
__author__ = 'James T. Dietrich'
__contact__ = 'james.t.dietrich@dartmouth.edu'
__copyright__ = '(c) James Dietrich 2016'
__license__ = 'MIT'
__date__ = 'Wed Nov 16 11:33:39 2016'
__version__ = '1.0'
__status__ = "initial release"
__url__ = "https://github.com/geojames/..."
"""
Name: Week6-1_Matplotlib_Adv.py
Compatibility: Python 3.5
Description: This program does stuff
URL: https://github.com/geojames/...
Requires: libraries
Dev ToDo:
AUTHOR: James T. Dietrich
ORGANIZATION: Dartmouth College
Contact: james.t.dietrich@dartmouth.edu
Copyright: (c) James Dietrich 2016
"""
#------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
# MESHGRID
#
# Meshgrid is a command/function that allows you to easily build X and Y
# grids from 1-D arrays/vectors which can be used to evaluate equations
# in 2D or 3D space
# different conventions for naming meshed variables
# x > xv
# x > xx
# x > xg
#
# meshgrid takes to 1-D arrays of X and Y coordinates and returns two X and Y
# "meshes" 2D arrays that cover the X and Y spaces
x = np.linspace(-10.,10.,30)
y = np.linspace(-10.,10.,30)
xg, yg = np.meshgrid(x,y)
r = np.sqrt((xg**2 + yg**2))
z = np.sin(r) * xg**2
plt.pcolor(z)
fig = plt.figure()
ax = Axes3D(fig)
ax.plot_surface(xg, yg, z,rstride=1, cstride=1, cmap='coolwarm')
# 3D Subplots
fig = plt.figure(figsize=plt.figaspect(0.33333))
ax1 = fig.add_subplot(1, 3, 1)
ax1.pcolor(z, cmap = 'hot')
ax2 = fig.add_subplot(1, 3, 2, projection='3d')
ax2.plot_surface(xg, yg, z,rstride=1, cstride=1, cmap='hot')
ax3 = fig.add_subplot(1, 3, 3, projection='3d')
ax3.contour(xg,yg,z)
#%% Formatted text for plots
#
# Matplotlib
# http://matplotlib.org/users/mathtext.html#mathtext-tutorial
# it basically uses TeX syntax and formatting codes
def f(x,y):
return (1 - x / 2 + x**5 + y**3) * np.exp(-x**2 -y**2)
n = 256
x = np.linspace(-3, 3, n)
y = np.linspace(-3, 3, n)
xx,yy = np.meshgrid(x, y)
#plt.axes([0.025, 0.025, 0.95, 0.95])
plt.contourf(xx, yy, f(xx, yy), 8, alpha=.75, cmap=plt.cm.hot)
C = plt.contour(xx, yy, f(xx, yy), 8, colors='black', linewidth=0.5)
plt.clabel(C, inline=1, fontsize=10)
plt.text (-2.5,-2,r'$\frac{1-x}{2 + x^5 + y^3} \times e^{(-x^2 -y^2)}$',fontsize=20)
plt.xlabel(r'$\mathbf{Bold \ x}$ x', fontsize=20)
plt.ylabel(r'$\mathit{Y-Label}$', fontsize=20)
plt.title('Regular ' r'$\mathbf{Bold}$ $\mathit{and \ italic}$ words')
#%% Double Y Axis Plots (from the Matplotlib Gallery)
fig, ax1 = plt.subplots()
t = np.arange(0.01, 10.0, 0.01)
s1 = np.exp(t)
ax1.plot(t, s1, 'b-')
ax1.set_xlabel('time (s)')
# Make the y-axis label and tick labels match the line color.
ax1.set_ylabel('exp', color='b')
for tl in ax1.get_yticklabels():
tl.set_color('b')
ax2 = ax1.twinx()
s2 = np.sin(2*np.pi*t)
ax2.plot(t, s2, 'r.')
ax2.set_ylabel('sin', color='r')
for tl in ax2.get_yticklabels():
tl.set_color('r') | geojames/Dart_EnvGIS | Week6-2_Matplotlib_Adv.py | Python | mit | 3,114 | 0.008992 |
# --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------------------------------
import uuid
import os
from knack.log import get_logger
from azure.cli.core.commands import LongRunningOperation
from azure.cli.command_modules.vm.custom import set_vm, _compute_client_factory, _is_linux_os
from azure.cli.command_modules.vm._vm_utils import get_key_vault_base_url, create_keyvault_data_plane_client
_DATA_VOLUME_TYPE = 'DATA'
_ALL_VOLUME_TYPE = 'ALL'
_STATUS_ENCRYPTED = 'Encrypted'
logger = get_logger(__name__)
vm_extension_info = {
'Linux': {
'publisher': os.environ.get('ADE_TEST_EXTENSION_PUBLISHER') or 'Microsoft.Azure.Security',
'name': os.environ.get('ADE_TEST_EXTENSION_NAME') or 'AzureDiskEncryptionForLinux',
'version': '1.1',
'legacy_version': '0.1'
},
'Windows': {
'publisher': os.environ.get('ADE_TEST_EXTENSION_PUBLISHER') or 'Microsoft.Azure.Security',
'name': os.environ.get('ADE_TEST_EXTENSION_NAME') or 'AzureDiskEncryption',
'version': '2.2',
'legacy_version': '1.1'
}
}
def _find_existing_ade(vm, use_instance_view=False, ade_ext_info=None):
if not ade_ext_info:
ade_ext_info = vm_extension_info['Linux'] if _is_linux_os(vm) else vm_extension_info['Windows']
if use_instance_view:
exts = vm.instance_view.extensions or []
r = next((e for e in exts if e.type and e.type.lower().startswith(ade_ext_info['publisher'].lower()) and
e.name.lower() == ade_ext_info['name'].lower()), None)
else:
exts = vm.resources or []
r = next((e for e in exts if (e.publisher.lower() == ade_ext_info['publisher'].lower() and
e.type_properties_type.lower() == ade_ext_info['name'].lower())), None)
return r
def _detect_ade_status(vm):
if vm.storage_profile.os_disk.encryption_settings:
return False, True
ade_ext_info = vm_extension_info['Linux'] if _is_linux_os(vm) else vm_extension_info['Windows']
ade = _find_existing_ade(vm, ade_ext_info=ade_ext_info)
if ade is None:
return False, False
if ade.type_handler_version.split('.')[0] == ade_ext_info['legacy_version'].split('.')[0]:
return False, True
return True, False # we believe impossible to have both old & new ADE
def encrypt_vm(cmd, resource_group_name, vm_name, # pylint: disable=too-many-locals, too-many-statements
disk_encryption_keyvault,
aad_client_id=None,
aad_client_secret=None, aad_client_cert_thumbprint=None,
key_encryption_keyvault=None,
key_encryption_key=None,
key_encryption_algorithm='RSA-OAEP',
volume_type=None,
encrypt_format_all=False,
force=False):
from msrestazure.tools import parse_resource_id
from knack.util import CLIError
# pylint: disable=no-member
compute_client = _compute_client_factory(cmd.cli_ctx)
vm = compute_client.virtual_machines.get(resource_group_name, vm_name)
is_linux = _is_linux_os(vm)
backup_encryption_settings = vm.storage_profile.os_disk.encryption_settings
vm_encrypted = backup_encryption_settings.enabled if backup_encryption_settings else False
_, has_old_ade = _detect_ade_status(vm)
use_new_ade = not aad_client_id and not has_old_ade
extension = vm_extension_info['Linux' if is_linux else 'Windows']
if not use_new_ade and not aad_client_id:
raise CLIError('Please provide --aad-client-id')
# 1. First validate arguments
if not use_new_ade and not aad_client_cert_thumbprint and not aad_client_secret:
raise CLIError('Please provide either --aad-client-cert-thumbprint or --aad-client-secret')
if volume_type is None:
if not is_linux:
volume_type = _ALL_VOLUME_TYPE
elif vm.storage_profile.data_disks:
raise CLIError('VM has data disks, please supply --volume-type')
else:
volume_type = 'OS'
# sequence_version should be unique
sequence_version = uuid.uuid4()
# retrieve keyvault details
disk_encryption_keyvault_url = get_key_vault_base_url(
cmd.cli_ctx, (parse_resource_id(disk_encryption_keyvault))['name'])
# disk encryption key itself can be further protected, so let us verify
if key_encryption_key:
key_encryption_keyvault = key_encryption_keyvault or disk_encryption_keyvault
# to avoid bad server errors, ensure the vault has the right configurations
_verify_keyvault_good_for_encryption(cmd.cli_ctx, disk_encryption_keyvault, key_encryption_keyvault, vm, force)
# if key name and not key url, get url.
if key_encryption_key and '://' not in key_encryption_key: # if key name and not key url
key_encryption_key = _get_keyvault_key_url(
cmd.cli_ctx, (parse_resource_id(key_encryption_keyvault))['name'], key_encryption_key)
# 2. we are ready to provision/update the disk encryption extensions
# The following logic was mostly ported from xplat-cli
public_config = {
'KeyVaultURL': disk_encryption_keyvault_url,
'VolumeType': volume_type,
'EncryptionOperation': 'EnableEncryption' if not encrypt_format_all else 'EnableEncryptionFormatAll',
'KeyEncryptionKeyURL': key_encryption_key,
'KeyEncryptionAlgorithm': key_encryption_algorithm,
'SequenceVersion': sequence_version,
}
if use_new_ade:
public_config.update({
"KeyVaultResourceId": disk_encryption_keyvault,
"KekVaultResourceId": key_encryption_keyvault if key_encryption_key else '',
})
else:
public_config.update({
'AADClientID': aad_client_id,
'AADClientCertThumbprint': aad_client_cert_thumbprint,
})
ade_legacy_private_config = {
'AADClientSecret': aad_client_secret if is_linux else (aad_client_secret or '')
}
VirtualMachineExtension, DiskEncryptionSettings, KeyVaultSecretReference, KeyVaultKeyReference, SubResource = \
cmd.get_models('VirtualMachineExtension', 'DiskEncryptionSettings', 'KeyVaultSecretReference',
'KeyVaultKeyReference', 'SubResource')
ext = VirtualMachineExtension(
location=vm.location, # pylint: disable=no-member
publisher=extension['publisher'],
type_properties_type=extension['name'],
protected_settings=None if use_new_ade else ade_legacy_private_config,
type_handler_version=extension['version'] if use_new_ade else extension['legacy_version'],
settings=public_config,
auto_upgrade_minor_version=True)
poller = compute_client.virtual_machine_extensions.begin_create_or_update(
resource_group_name, vm_name, extension['name'], ext)
LongRunningOperation(cmd.cli_ctx)(poller)
poller.result()
# verify the extension was ok
extension_result = compute_client.virtual_machine_extensions.get(
resource_group_name, vm_name, extension['name'], 'instanceView')
if extension_result.provisioning_state != 'Succeeded':
raise CLIError('Extension needed for disk encryption was not provisioned correctly')
if not use_new_ade:
if not (extension_result.instance_view.statuses and
extension_result.instance_view.statuses[0].message):
raise CLIError('Could not find url pointing to the secret for disk encryption')
# 3. update VM's storage profile with the secrets
status_url = extension_result.instance_view.statuses[0].message
vm = compute_client.virtual_machines.get(resource_group_name, vm_name)
secret_ref = KeyVaultSecretReference(secret_url=status_url,
source_vault=SubResource(id=disk_encryption_keyvault))
key_encryption_key_obj = None
if key_encryption_key:
key_encryption_key_obj = KeyVaultKeyReference(key_url=key_encryption_key,
source_vault=SubResource(id=key_encryption_keyvault))
disk_encryption_settings = DiskEncryptionSettings(disk_encryption_key=secret_ref,
key_encryption_key=key_encryption_key_obj,
enabled=True)
if vm_encrypted:
# stop the vm before update if the vm is already encrypted
logger.warning("Deallocating the VM before updating encryption settings...")
compute_client.virtual_machines.deallocate(resource_group_name, vm_name).result()
vm = compute_client.virtual_machines.get(resource_group_name, vm_name)
vm.storage_profile.os_disk.encryption_settings = disk_encryption_settings
set_vm(cmd, vm)
if vm_encrypted:
# and start after the update
logger.warning("Restarting the VM after the update...")
compute_client.virtual_machines.start(resource_group_name, vm_name).result()
if is_linux and volume_type != _DATA_VOLUME_TYPE:
old_ade_msg = "If you see 'VMRestartPending', please restart the VM, and the encryption will finish shortly"
logger.warning("The encryption request was accepted. Please use 'show' command to monitor "
"the progress. %s", "" if use_new_ade else old_ade_msg)
def decrypt_vm(cmd, resource_group_name, vm_name, volume_type=None, force=False):
from knack.util import CLIError
compute_client = _compute_client_factory(cmd.cli_ctx)
vm = compute_client.virtual_machines.get(resource_group_name, vm_name)
has_new_ade, has_old_ade = _detect_ade_status(vm)
if not has_new_ade and not has_old_ade:
logger.warning('Azure Disk Encryption is not enabled')
return
is_linux = _is_linux_os(vm)
# pylint: disable=no-member
# 1. be nice, figure out the default volume type and also verify VM will not be busted
if is_linux:
if volume_type:
if not force and volume_type != _DATA_VOLUME_TYPE:
raise CLIError("Only Data disks can have encryption disabled in a Linux VM. "
"Use '--force' to ignore the warning")
else:
volume_type = _DATA_VOLUME_TYPE
elif volume_type is None:
volume_type = _ALL_VOLUME_TYPE
extension = vm_extension_info['Linux' if is_linux else 'Windows']
# sequence_version should be incremented since encryptions occurred before
sequence_version = uuid.uuid4()
# 2. update the disk encryption extension
# The following logic was mostly ported from xplat-cli
public_config = {
'VolumeType': volume_type,
'EncryptionOperation': 'DisableEncryption',
'SequenceVersion': sequence_version,
}
VirtualMachineExtension, DiskEncryptionSettings = cmd.get_models(
'VirtualMachineExtension', 'DiskEncryptionSettings')
ext = VirtualMachineExtension(
location=vm.location, # pylint: disable=no-member
publisher=extension['publisher'],
virtual_machine_extension_type=extension['name'],
type_handler_version=extension['version'] if has_new_ade else extension['legacy_version'],
settings=public_config,
auto_upgrade_minor_version=True)
poller = compute_client.virtual_machine_extensions.begin_create_or_update(resource_group_name,
vm_name,
extension['name'], ext)
LongRunningOperation(cmd.cli_ctx)(poller)
poller.result()
extension_result = compute_client.virtual_machine_extensions.get(resource_group_name, vm_name,
extension['name'],
'instanceView')
if extension_result.provisioning_state != 'Succeeded':
raise CLIError("Extension updating didn't succeed")
if not has_new_ade:
# 3. Remove the secret from VM's storage profile
vm = compute_client.virtual_machines.get(resource_group_name, vm_name)
disk_encryption_settings = DiskEncryptionSettings(enabled=False)
vm.storage_profile.os_disk.encryption_settings = disk_encryption_settings
set_vm(cmd, vm)
def _show_vm_encryption_status_thru_new_ade(vm_instance_view):
ade = _find_existing_ade(vm_instance_view, use_instance_view=True)
disk_infos = []
for div in vm_instance_view.instance_view.disks or []:
disk_infos.append({
'name': div.name,
'encryptionSettings': div.encryption_settings,
'statuses': [x for x in (div.statuses or []) if (x.code or '').startswith('EncryptionState')],
})
return {
'status': ade.statuses if ade else None,
'substatus': ade.substatuses if ade else None,
'disks': disk_infos
}
def show_vm_encryption_status(cmd, resource_group_name, vm_name):
encryption_status = {
'osDisk': 'NotEncrypted',
'osDiskEncryptionSettings': None,
'dataDisk': 'NotEncrypted',
'osType': None
}
compute_client = _compute_client_factory(cmd.cli_ctx)
vm = compute_client.virtual_machines.get(resource_group_name, vm_name, 'instanceView')
has_new_ade, has_old_ade = _detect_ade_status(vm)
if not has_new_ade and not has_old_ade:
logger.warning('Azure Disk Encryption is not enabled')
return None
if has_new_ade:
return _show_vm_encryption_status_thru_new_ade(vm)
is_linux = _is_linux_os(vm)
# pylint: disable=no-member
# The following logic was mostly ported from xplat-cli
os_type = 'Linux' if is_linux else 'Windows'
encryption_status['osType'] = os_type
extension = vm_extension_info[os_type]
extension_result = compute_client.virtual_machine_extensions.get(resource_group_name,
vm_name,
extension['name'],
'instanceView')
logger.debug(extension_result)
if extension_result.instance_view and extension_result.instance_view.statuses:
encryption_status['progressMessage'] = extension_result.instance_view.statuses[0].message
substatus_message = None
if getattr(extension_result.instance_view, 'substatuses', None):
substatus_message = extension_result.instance_view.substatuses[0].message
encryption_status['osDiskEncryptionSettings'] = vm.storage_profile.os_disk.encryption_settings
import json
if is_linux:
try:
message_object = json.loads(substatus_message)
except Exception: # pylint: disable=broad-except
message_object = None # might be from outdated extension
if message_object and ('os' in message_object):
encryption_status['osDisk'] = message_object['os']
else:
encryption_status['osDisk'] = 'Unknown'
if message_object and 'data' in message_object:
encryption_status['dataDisk'] = message_object['data']
else:
encryption_status['dataDisk'] = 'Unknown'
else:
# Windows - get os and data volume encryption state from the vm model
if (encryption_status['osDiskEncryptionSettings'] and
encryption_status['osDiskEncryptionSettings'].enabled and
encryption_status['osDiskEncryptionSettings'].disk_encryption_key and
encryption_status['osDiskEncryptionSettings'].disk_encryption_key.secret_url):
encryption_status['osDisk'] = _STATUS_ENCRYPTED
else:
encryption_status['osDisk'] = 'Unknown'
if extension_result.provisioning_state == 'Succeeded':
volume_type = extension_result.settings.get('VolumeType', None)
about_data_disk = not volume_type or volume_type.lower() != 'os'
if about_data_disk and extension_result.settings.get('EncryptionOperation', None) == 'EnableEncryption':
encryption_status['dataDisk'] = _STATUS_ENCRYPTED
return encryption_status
def _get_keyvault_key_url(cli_ctx, keyvault_name, key_name):
client = create_keyvault_data_plane_client(cli_ctx)
result = client.get_key(get_key_vault_base_url(cli_ctx, keyvault_name), key_name, '')
return result.key.kid # pylint: disable=no-member
def _handles_default_volume_type_for_vmss_encryption(is_linux, volume_type, force):
if is_linux:
volume_type = volume_type or _DATA_VOLUME_TYPE
if volume_type != _DATA_VOLUME_TYPE:
msg = 'OS disk encyrption is not yet supported for Linux VM scale sets'
if force:
logger.warning(msg)
else:
from knack.util import CLIError
raise CLIError(msg)
else:
volume_type = volume_type or _ALL_VOLUME_TYPE
return volume_type
def encrypt_vmss(cmd, resource_group_name, vmss_name, # pylint: disable=too-many-locals, too-many-statements
disk_encryption_keyvault,
key_encryption_keyvault=None,
key_encryption_key=None,
key_encryption_algorithm='RSA-OAEP',
volume_type=None,
force=False):
from msrestazure.tools import parse_resource_id
# pylint: disable=no-member
UpgradeMode, VirtualMachineScaleSetExtension, VirtualMachineScaleSetExtensionProfile = cmd.get_models(
'UpgradeMode', 'VirtualMachineScaleSetExtension', 'VirtualMachineScaleSetExtensionProfile')
compute_client = _compute_client_factory(cmd.cli_ctx)
vmss = compute_client.virtual_machine_scale_sets.get(resource_group_name, vmss_name)
is_linux = _is_linux_os(vmss.virtual_machine_profile)
extension = vm_extension_info['Linux' if is_linux else 'Windows']
# 1. First validate arguments
volume_type = _handles_default_volume_type_for_vmss_encryption(is_linux, volume_type, force)
# retrieve keyvault details
disk_encryption_keyvault_url = get_key_vault_base_url(cmd.cli_ctx,
(parse_resource_id(disk_encryption_keyvault))['name'])
# disk encryption key itself can be further protected, so let us verify
if key_encryption_key:
key_encryption_keyvault = key_encryption_keyvault or disk_encryption_keyvault
# to avoid bad server errors, ensure the vault has the right configurations
_verify_keyvault_good_for_encryption(cmd.cli_ctx, disk_encryption_keyvault, key_encryption_keyvault, vmss, force)
# if key name and not key url, get url.
if key_encryption_key and '://' not in key_encryption_key:
key_encryption_key = _get_keyvault_key_url(
cmd.cli_ctx, (parse_resource_id(key_encryption_keyvault))['name'], key_encryption_key)
# 2. we are ready to provision/update the disk encryption extensions
public_config = {
'KeyVaultURL': disk_encryption_keyvault_url,
'KeyEncryptionKeyURL': key_encryption_key or '',
"KeyVaultResourceId": disk_encryption_keyvault,
"KekVaultResourceId": key_encryption_keyvault if key_encryption_key else '',
'KeyEncryptionAlgorithm': key_encryption_algorithm if key_encryption_key else '',
'VolumeType': volume_type,
'EncryptionOperation': 'EnableEncryption'
}
ext = VirtualMachineScaleSetExtension(name=extension['name'],
publisher=extension['publisher'],
type_properties_type=extension['name'],
type_handler_version=extension['version'],
settings=public_config,
auto_upgrade_minor_version=True,
force_update_tag=uuid.uuid4())
exts = [ext]
# remove any old ade extensions set by this command and add the new one.
vmss_ext_profile = vmss.virtual_machine_profile.extension_profile
if vmss_ext_profile and vmss_ext_profile.extensions:
exts.extend(old_ext for old_ext in vmss.virtual_machine_profile.extension_profile.extensions
if old_ext.type != ext.type or old_ext.name != ext.name)
vmss.virtual_machine_profile.extension_profile = VirtualMachineScaleSetExtensionProfile(extensions=exts)
# Avoid unnecessary permission error
vmss.virtual_machine_profile.storage_profile.image_reference = None
poller = compute_client.virtual_machine_scale_sets.begin_create_or_update(resource_group_name, vmss_name, vmss)
LongRunningOperation(cmd.cli_ctx)(poller)
_show_post_action_message(resource_group_name, vmss.name, vmss.upgrade_policy.mode == UpgradeMode.manual, True)
def decrypt_vmss(cmd, resource_group_name, vmss_name, volume_type=None, force=False):
UpgradeMode, VirtualMachineScaleSetExtension = cmd.get_models('UpgradeMode', 'VirtualMachineScaleSetExtension')
compute_client = _compute_client_factory(cmd.cli_ctx)
vmss = compute_client.virtual_machine_scale_sets.get(resource_group_name, vmss_name)
is_linux = _is_linux_os(vmss.virtual_machine_profile)
extension = vm_extension_info['Linux' if is_linux else 'Windows']
# 1. be nice, figure out the default volume type
volume_type = _handles_default_volume_type_for_vmss_encryption(is_linux, volume_type, force)
# 2. update the disk encryption extension
public_config = {
'VolumeType': volume_type,
'EncryptionOperation': 'DisableEncryption',
}
ext = VirtualMachineScaleSetExtension(name=extension['name'],
publisher=extension['publisher'],
type_properties_type=extension['name'],
type_handler_version=extension['version'],
settings=public_config,
auto_upgrade_minor_version=True,
force_update_tag=uuid.uuid4())
if (not vmss.virtual_machine_profile.extension_profile or
not vmss.virtual_machine_profile.extension_profile.extensions):
extensions = []
else:
extensions = vmss.virtual_machine_profile.extension_profile.extensions
ade_extension = [x for x in extensions if
x.type_properties_type.lower() == extension['name'].lower() and x.publisher.lower() == extension['publisher'].lower()] # pylint: disable=line-too-long
if not ade_extension:
from knack.util import CLIError
raise CLIError("VM scale set '{}' was not encrypted".format(vmss_name))
index = vmss.virtual_machine_profile.extension_profile.extensions.index(ade_extension[0])
vmss.virtual_machine_profile.extension_profile.extensions[index] = ext
# Avoid unnecessary permission error
vmss.virtual_machine_profile.storage_profile.image_reference = None
poller = compute_client.virtual_machine_scale_sets.begin_create_or_update(resource_group_name, vmss_name, vmss)
LongRunningOperation(cmd.cli_ctx)(poller)
_show_post_action_message(resource_group_name, vmss.name, vmss.upgrade_policy.mode == UpgradeMode.manual, False)
def _show_post_action_message(resource_group_name, vmss_name, maunal_mode, enable):
msg = ''
if maunal_mode:
msg = ("With manual upgrade mode, you will need to run 'az vmss update-instances -g {} -n {} "
"--instance-ids \"*\"' to propagate the change.\n".format(resource_group_name, vmss_name))
msg += ("Note, {} encryption will take a while to finish. Please query the status using "
"'az vmss encryption show -g {} -n {}'. For Linux VM, you will lose the access during the period".format(
'enabling' if enable else 'disabling', resource_group_name, vmss_name))
logger.warning(msg)
def show_vmss_encryption_status(cmd, resource_group_name, vmss_name):
client = _compute_client_factory(cmd.cli_ctx)
vm_instances = list(client.virtual_machine_scale_set_vms.list(resource_group_name, vmss_name,
select='instanceView', expand='instanceView'))
result = []
for instance in vm_instances:
view = instance.instance_view
disk_infos = []
vm_enc_info = {
'id': instance.id,
'disks': disk_infos
}
for div in view.disks:
disk_infos.append({
'name': div.name,
'encryptionSettings': div.encryption_settings,
'statuses': [x for x in (div.statuses or []) if (x.code or '').startswith('EncryptionState')]
})
result.append(vm_enc_info)
return result
def _verify_keyvault_good_for_encryption(cli_ctx, disk_vault_id, kek_vault_id, vm_or_vmss, force):
def _report_client_side_validation_error(msg):
if force:
logger.warning("WARNING: %s %s", msg, "Encryption might fail.")
else:
from knack.util import CLIError
raise CLIError("ERROR: {}".format(msg))
resource_type = "VMSS" if vm_or_vmss.type.lower().endswith("virtualmachinescalesets") else "VM"
from azure.cli.core.commands.client_factory import get_mgmt_service_client
from azure.cli.core.profiles import ResourceType
from msrestazure.tools import parse_resource_id
client = get_mgmt_service_client(cli_ctx, ResourceType.MGMT_KEYVAULT).vaults
disk_vault_resource_info = parse_resource_id(disk_vault_id)
key_vault = client.get(disk_vault_resource_info['resource_group'], disk_vault_resource_info['name'])
# ensure vault has 'EnabledForDiskEncryption' permission
if not key_vault.properties or not key_vault.properties.enabled_for_disk_encryption:
_report_client_side_validation_error("Keyvault '{}' is not enabled for disk encryption.".format(
disk_vault_resource_info['resource_name']))
if kek_vault_id:
kek_vault_info = parse_resource_id(kek_vault_id)
if disk_vault_resource_info['name'].lower() != kek_vault_info['name'].lower():
client.get(kek_vault_info['resource_group'], kek_vault_info['name'])
# verify subscription mataches
vm_vmss_resource_info = parse_resource_id(vm_or_vmss.id)
if vm_vmss_resource_info['subscription'].lower() != disk_vault_resource_info['subscription'].lower():
_report_client_side_validation_error("{} {}'s subscription does not match keyvault's subscription."
.format(resource_type, vm_vmss_resource_info['name']))
# verify region matches
if key_vault.location.replace(' ', '').lower() != vm_or_vmss.location.replace(' ', '').lower():
_report_client_side_validation_error(
"{} {}'s region does not match keyvault's region.".format(resource_type, vm_vmss_resource_info['name']))
| yugangw-msft/azure-cli | src/azure-cli/azure/cli/command_modules/vm/disk_encryption.py | Python | mit | 27,499 | 0.004291 |
import tornado.web
import traceback
from plugins.bases.plugin import PluginBase
import os
import sys
import gdata
import gdata.youtube
import gdata.youtube.service
class HandlersBase(tornado.web.RequestHandler, PluginBase):
# Every handler must have a web path, override this in this fashion
WEB_PATH = r"/"
STORE_ATTRS = True
STORE_UNREF = True
# Specifies what JS and CSS files to load from templates/bootstrap/[css|js]
JS_FILES = []
CSS_FILES = []
# Used as a default for every page
PAGE_TITLE = "Home"
def initialize(self, **kwargs):
self.sysconf = kwargs.get("sysconf", None)
def get_template_path(self):
return "%s/templates" % os.path.dirname(os.path.realpath(sys.argv[0]))
# Initialize YouTube reference to perform actions
def yt_instance(self):
self.yt_service = gdata.youtube.service.YouTubeService()
self.yt_service.ssl = True
self.yt_service.developer_key = self.sysconf.devid
self.yt_service.client_id = self.sysconf.clientid
self.yt_service.email = self.sysconf.gmail
self.yt_service.password = self.sysconf.gpass
self.yt_service.source = self.sysconf.clientid
self.yt_service.ProgrammaticLogin()
# Simple class property to return the playlist URI
@property
def yt_plist_uri(self):
return "http://gdata.youtube.com/feeds/api/playlists/%s" % self.sysconf.playlist
# Return the data about the playlist
def yt_playlist(self):
return self.yt_service.GetYouTubePlaylistVideoFeed(uri=self.yt_plist_uri)
# Get total number of videos in playlist
def yt_playlist_count(self):
plist = self.yt_playlist()
entry = []
for e in plist.entry:
entry.append(e)
return len(entry)
# Wrapper to get upload token for YouTube video post request
def yt_uploadtoken(self, mg):
video_entry = gdata.youtube.YouTubeVideoEntry(media=mg)
response = self.yt_service.GetFormUploadToken(video_entry)
return (response[0], response[1])
# This defines various aspects of the video
def yt_mediagroup(self, title, desc):
return gdata.media.Group(
title = gdata.media.Title(text=title),
description = gdata.media.Description(description_type='plain', text=desc),
keywords=gdata.media.Keywords(text='amber, eric, wedding, 2013, october, 31, halloween'),
category=[gdata.media.Category(
text='People',
scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
label='People')],
player=None
)
# Adds a video to playlist
def yt_vid2pl(self, vidid, title, desc):
video_entry = self.yt_service.AddPlaylistVideoEntryToPlaylist(
self.yt_plist_uri, vidid, title, desc
)
if isinstance(video_entry, gdata.youtube.YouTubePlaylistVideoEntry):
return 1
return 0
"""
show
Wrapper around RequestHandler's render function to make rendering these templates easier/better.
This way the class just has to specify what special CSS and/or JavaScript files to load (see handlers/main),
and it is automatically passed to the template engine to parse and deal with.
Easier management and use IMO.
"""
def show(self, templ, **kwargs):
# What JavaScript files to load?
js = ["jquery", "bootstrap.min", "common", "jquery.prettyPhoto"]
js.extend(self.JS_FILES)
# CSS files we want for the particular page
css = ["common", "prettyPhoto"]
css.extend(self.CSS_FILES)
# We pass specifics to the page as well as any uniques via kwargs passed from here
self.render("%s.html" % templ,
js=js, css=css,
page_title=self.PAGE_TITLE,
plistid=self.sysconf.playlist,
**kwargs)
def write_error(self, status_code, **kwargs):
path = os.path.dirname(os.path.realpath(sys.argv[0]))
_,err,_ = kwargs['exc_info']
msg = "Unfortunately an error has occured. If you believe this is in error, please contact support.<br /><br />"
msg += "Error: %s" % (err)
self.show("%s/templates/message" % path, path=path, message=msg)
| anzenehansen/wedding-photos | plugins/bases/handlers.py | Python | mpl-2.0 | 4,489 | 0.008911 |
"""Initial
Revision ID: cfbd6d35cab
Revises:
Create Date: 2015-03-04 04:13:56.547992
"""
# revision identifiers, used by Alembic.
revision = 'cfbd6d35cab'
down_revision = None
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table('location',
sa.Column('city', sa.String(length=50), nullable=True),
sa.Column('zip', sa.String(length=9), nullable=True),
sa.Column('county', sa.String(length=50), nullable=True),
sa.Column('state', sa.String(length=2), nullable=True),
sa.Column('address_1', sa.String(length=100), nullable=True),
sa.Column('address_2', sa.String(length=100), nullable=True),
sa.Column('location_source_value', sa.String(length=300), nullable=True),
sa.Column('location_id', sa.Integer(), nullable=False),
sa.PrimaryKeyConstraint('location_id', name=op.f('pk_location'))
)
op.create_index(op.f('ix_location_location_id'), 'location', ['location_id'], unique=False, postgresql_ops={})
op.create_table('cohort',
sa.Column('cohort_end_date', sa.DateTime(), nullable=True),
sa.Column('cohort_id', sa.Integer(), nullable=False),
sa.Column('subject_id', sa.Integer(), nullable=False),
sa.Column('stop_reason', sa.String(length=100), nullable=True),
sa.Column('cohort_concept_id', sa.Integer(), nullable=False),
sa.Column('cohort_start_date', sa.DateTime(), nullable=False),
sa.PrimaryKeyConstraint('cohort_id', name=op.f('pk_cohort'))
)
op.create_index(op.f('ix_cohort_cohort_id'), 'cohort', ['cohort_id'], unique=False, postgresql_ops={})
op.create_table('organization',
sa.Column('organization_id', sa.Integer(), nullable=False),
sa.Column('place_of_service_concept_id', sa.Integer(), nullable=True),
sa.Column('place_of_service_source_value', sa.String(length=100), nullable=True),
sa.Column('location_id', sa.Integer(), nullable=True),
sa.Column('organization_source_value', sa.String(length=50), nullable=False),
sa.ForeignKeyConstraint(['location_id'], [u'location.location_id'], name=op.f('fk_organization_location_id_location')),
sa.PrimaryKeyConstraint('organization_id', name=op.f('pk_organization')),
sa.UniqueConstraint('organization_source_value', name=op.f('uq_organization_organization_source_value'))
)
op.create_index(op.f('ix_organization_location_id'), 'organization', ['location_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_organization_organization_id'), 'organization', ['organization_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_organization_organization_source_value_place_of_service_source_value'), 'organization', ['organization_source_value', 'place_of_service_source_value'], unique=False, postgresql_ops={u'place_of_service_source_value': u'varchar_pattern_ops', u'organization_source_value': u'varchar_pattern_ops'})
op.create_table('care_site',
sa.Column('place_of_service_source_value', sa.String(length=100), nullable=True),
sa.Column('place_of_service_concept_id', sa.Integer(), nullable=True),
sa.Column('care_site_source_value', sa.String(length=100), nullable=False),
sa.Column('organization_id', sa.Integer(), nullable=False),
sa.Column('care_site_id', sa.Integer(), nullable=False),
sa.Column('location_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['location_id'], [u'location.location_id'], name=op.f('fk_care_site_location_id_location')),
sa.ForeignKeyConstraint(['organization_id'], [u'organization.organization_id'], name=op.f('fk_care_site_organization_id_organization')),
sa.PrimaryKeyConstraint('care_site_id', name=op.f('pk_care_site')),
sa.UniqueConstraint('organization_id', 'care_site_source_value', name=op.f('uq_care_site_organization_id_care_site_source_value'))
)
op.create_index(op.f('ix_care_site_care_site_id'), 'care_site', ['care_site_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_care_site_location_id'), 'care_site', ['location_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_care_site_organization_id'), 'care_site', ['organization_id'], unique=False, postgresql_ops={})
op.create_table('provider',
sa.Column('provider_id', sa.Integer(), nullable=False),
sa.Column('npi', sa.String(length=20), nullable=True),
sa.Column('specialty_concept_id', sa.Integer(), nullable=True),
sa.Column('provider_source_value', sa.String(length=100), nullable=False),
sa.Column('dea', sa.String(length=20), nullable=True),
sa.Column('care_site_id', sa.Integer(), nullable=False),
sa.Column('specialty_source_value', sa.String(length=300), nullable=True),
sa.ForeignKeyConstraint(['care_site_id'], [u'care_site.care_site_id'], name=op.f('fk_provider_care_site_id_care_site')),
sa.PrimaryKeyConstraint('provider_id', name=op.f('pk_provider'))
)
op.create_index(op.f('ix_provider_care_site_id'), 'provider', ['care_site_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_provider_provider_id'), 'provider', ['provider_id'], unique=False, postgresql_ops={})
op.create_table('person',
sa.Column('provider_id', sa.Integer(), nullable=True),
sa.Column('ethnicity_concept_id', sa.Integer(), nullable=True),
sa.Column('ethnicity_source_value', sa.String(length=50), nullable=True),
sa.Column('person_source_value', sa.String(length=100), nullable=False),
sa.Column('month_of_birth', sa.Numeric(precision=2, scale=0), nullable=True),
sa.Column('pn_time_of_birth', sa.DateTime(), nullable=True),
sa.Column('day_of_birth', sa.Numeric(precision=2, scale=0), nullable=True),
sa.Column('year_of_birth', sa.Numeric(precision=4, scale=0), nullable=False),
sa.Column('gender_source_value', sa.String(length=50), nullable=True),
sa.Column('race_source_value', sa.String(length=50), nullable=True),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('care_site_id', sa.Integer(), nullable=False),
sa.Column('gender_concept_id', sa.Integer(), nullable=False),
sa.Column('location_id', sa.Integer(), nullable=True),
sa.Column('race_concept_id', sa.Integer(), nullable=True),
sa.Column('pn_gestational_age', sa.Numeric(precision=4, scale=2), nullable=True),
sa.ForeignKeyConstraint(['care_site_id'], [u'care_site.care_site_id'], name=op.f('fk_person_care_site_id_care_site')),
sa.ForeignKeyConstraint(['location_id'], [u'location.location_id'], name=op.f('fk_person_location_id_location')),
sa.ForeignKeyConstraint(['provider_id'], [u'provider.provider_id'], name=op.f('fk_person_provider_id_provider')),
sa.PrimaryKeyConstraint('person_id', name=op.f('pk_person')),
sa.UniqueConstraint('person_source_value', name=op.f('uq_person_person_source_value'))
)
op.create_index(op.f('ix_person_care_site_id'), 'person', ['care_site_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_person_location_id'), 'person', ['location_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_person_person_id'), 'person', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_person_provider_id'), 'person', ['provider_id'], unique=False, postgresql_ops={})
op.create_table('death',
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('death_type_concept_id', sa.Integer(), autoincrement=False, nullable=False),
sa.Column('death_date', sa.DateTime(), nullable=False),
sa.Column('cause_of_death_concept_id', sa.Integer(), autoincrement=False, nullable=False),
sa.Column('cause_of_death_source_value', sa.String(length=100), nullable=True),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_death_person_id_person')),
sa.PrimaryKeyConstraint('person_id', 'death_type_concept_id', 'cause_of_death_concept_id', name=op.f('pk_death'))
)
op.create_index(op.f('ix_death_person_id'), 'death', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_death_person_id_death_type_concept_id_cause_of_death_concept_id'), 'death', ['person_id', 'death_type_concept_id', 'cause_of_death_concept_id'], unique=False, postgresql_ops={})
op.create_table('visit_occurrence',
sa.Column('provider_id', sa.Integer(), nullable=True),
sa.Column('place_of_service_concept_id', sa.Integer(), nullable=False),
sa.Column('visit_start_date', sa.DateTime(), nullable=False),
sa.Column('place_of_service_source_value', sa.String(length=100), nullable=True),
sa.Column('visit_end_date', sa.DateTime(), nullable=True),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('care_site_id', sa.Integer(), nullable=True),
sa.Column('visit_occurrence_id', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_visit_occurrence_person_id_person')),
sa.PrimaryKeyConstraint('visit_occurrence_id', name=op.f('pk_visit_occurrence'))
)
op.create_index(op.f('ix_visit_occurrence_person_id'), 'visit_occurrence', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_visit_occurrence_person_id_visit_start_date'), 'visit_occurrence', ['person_id', 'visit_start_date'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_visit_occurrence_visit_occurrence_id'), 'visit_occurrence', ['visit_occurrence_id'], unique=False, postgresql_ops={})
op.create_table('payer_plan_period',
sa.Column('plan_source_value', sa.String(length=100), nullable=True),
sa.Column('family_source_value', sa.String(length=100), nullable=True),
sa.Column('payer_plan_period_id', sa.Integer(), nullable=False),
sa.Column('payer_plan_period_end_date', sa.DateTime(), nullable=False),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('payer_source_value', sa.String(length=100), nullable=True),
sa.Column('payer_plan_period_start_date', sa.DateTime(), nullable=False),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_payer_plan_period_person_id_person')),
sa.PrimaryKeyConstraint('payer_plan_period_id', name=op.f('pk_payer_plan_period'))
)
op.create_index(op.f('ix_payer_plan_period_payer_plan_period_id'), 'payer_plan_period', ['payer_plan_period_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_payer_plan_period_person_id'), 'payer_plan_period', ['person_id'], unique=False, postgresql_ops={})
op.create_table('drug_era',
sa.Column('drug_era_end_date', sa.DateTime(), nullable=False),
sa.Column('drug_era_start_date', sa.DateTime(), nullable=False),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('drug_era_id', sa.Integer(), nullable=False),
sa.Column('drug_exposure_count', sa.Numeric(precision=4, scale=0), nullable=True),
sa.Column('drug_type_concept_id', sa.Integer(), nullable=False),
sa.Column('drug_concept_id', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_drug_era_person_id_person')),
sa.PrimaryKeyConstraint('drug_era_id', name=op.f('pk_drug_era'))
)
op.create_index(op.f('ix_drug_era_drug_era_id'), 'drug_era', ['drug_era_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_drug_era_person_id'), 'drug_era', ['person_id'], unique=False, postgresql_ops={})
op.create_table('observation_period',
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('observation_period_end_date', sa.DateTime(), nullable=True),
sa.Column('observation_period_start_date', sa.DateTime(), nullable=False),
sa.Column('observation_period_id', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_observation_period_person_id_person')),
sa.PrimaryKeyConstraint('observation_period_id', name=op.f('pk_observation_period'))
)
op.create_index(op.f('ix_observation_period_observation_period_id'), 'observation_period', ['observation_period_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_observation_period_person_id'), 'observation_period', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_observation_period_person_id_observation_period_start_date'), 'observation_period', ['person_id', 'observation_period_start_date'], unique=False, postgresql_ops={})
op.create_table('condition_era',
sa.Column('condition_concept_id', sa.Integer(), nullable=False),
sa.Column('condition_occurrence_count', sa.Numeric(precision=4, scale=0), nullable=True),
sa.Column('condition_era_id', sa.Integer(), nullable=False),
sa.Column('condition_type_concept_id', sa.Integer(), nullable=False),
sa.Column('condition_era_start_date', sa.DateTime(), nullable=False),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('condition_era_end_date', sa.DateTime(), nullable=False),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_condition_era_person_id_person')),
sa.PrimaryKeyConstraint('condition_era_id', name=op.f('pk_condition_era'))
)
op.create_index(op.f('ix_condition_era_condition_era_id'), 'condition_era', ['condition_era_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_condition_era_person_id'), 'condition_era', ['person_id'], unique=False, postgresql_ops={})
op.create_table('observation',
sa.Column('range_high', sa.Numeric(precision=14, scale=3), nullable=True),
sa.Column('observation_concept_id', sa.Integer(), nullable=False),
sa.Column('range_low', sa.Numeric(precision=14, scale=3), nullable=True),
sa.Column('observation_id', sa.Integer(), nullable=False),
sa.Column('relevant_condition_concept_id', sa.Integer(), nullable=True),
sa.Column('observation_time', sa.DateTime(), nullable=True),
sa.Column('unit_concept_id', sa.Integer(), nullable=True),
sa.Column('value_as_number', sa.Numeric(precision=14, scale=3), nullable=True),
sa.Column('observation_source_value', sa.String(length=100), nullable=True),
sa.Column('value_as_string', sa.String(length=4000), nullable=True),
sa.Column('observation_type_concept_id', sa.Integer(), nullable=False),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('observation_date', sa.DateTime(), nullable=False),
sa.Column('value_as_concept_id', sa.Integer(), nullable=True),
sa.Column('associated_provider_id', sa.Integer(), nullable=True),
sa.Column('visit_occurrence_id', sa.Integer(), nullable=True),
sa.Column('units_source_value', sa.String(length=100), nullable=True),
sa.ForeignKeyConstraint(['associated_provider_id'], [u'provider.provider_id'], name=op.f('fk_observation_associated_provider_id_provider')),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_observation_person_id_person')),
sa.ForeignKeyConstraint(['visit_occurrence_id'], [u'visit_occurrence.visit_occurrence_id'], name=op.f('fk_observation_visit_occurrence_id_visit_occurrence')),
sa.PrimaryKeyConstraint('observation_id', name=op.f('pk_observation'))
)
op.create_index(op.f('ix_observation_associated_provider_id'), 'observation', ['associated_provider_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_observation_observation_id'), 'observation', ['observation_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_observation_person_id'), 'observation', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_observation_person_id_observation_concept_id'), 'observation', ['person_id', 'observation_concept_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_observation_visit_occurrence_id'), 'observation', ['visit_occurrence_id'], unique=False, postgresql_ops={})
op.create_table('drug_exposure',
sa.Column('refills', sa.Numeric(precision=3, scale=0), nullable=True),
sa.Column('stop_reason', sa.String(length=100), nullable=True),
sa.Column('relevant_condition_concept_id', sa.Integer(), nullable=True),
sa.Column('days_supply', sa.Numeric(precision=4, scale=0), nullable=True),
sa.Column('drug_exposure_start_date', sa.DateTime(), nullable=False),
sa.Column('prescribing_provider_id', sa.Integer(), nullable=True),
sa.Column('sig', sa.String(length=500), nullable=True),
sa.Column('drug_exposure_id', sa.Integer(), nullable=False),
sa.Column('drug_source_value', sa.String(length=100), nullable=True),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('drug_exposure_end_date', sa.DateTime(), nullable=True),
sa.Column('visit_occurrence_id', sa.Integer(), nullable=True),
sa.Column('drug_type_concept_id', sa.Integer(), nullable=False),
sa.Column('drug_concept_id', sa.Integer(), nullable=False),
sa.Column('quantity', sa.Numeric(precision=4, scale=0), nullable=True),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_drug_exposure_person_id_person')),
sa.ForeignKeyConstraint(['prescribing_provider_id'], [u'provider.provider_id'], name=op.f('fk_drug_exposure_prescribing_provider_id_provider')),
sa.ForeignKeyConstraint(['visit_occurrence_id'], [u'visit_occurrence.visit_occurrence_id'], name=op.f('fk_drug_exposure_visit_occurrence_id_visit_occurrence')),
sa.PrimaryKeyConstraint('drug_exposure_id', name=op.f('pk_drug_exposure'))
)
op.create_index(op.f('ix_drug_exposure_drug_exposure_id'), 'drug_exposure', ['drug_exposure_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_drug_exposure_person_id'), 'drug_exposure', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_drug_exposure_prescribing_provider_id'), 'drug_exposure', ['prescribing_provider_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_drug_exposure_visit_occurrence_id'), 'drug_exposure', ['visit_occurrence_id'], unique=False, postgresql_ops={})
op.create_table('procedure_occurrence',
sa.Column('procedure_concept_id', sa.Integer(), nullable=False),
sa.Column('relevant_condition_concept_id', sa.Integer(), nullable=True),
sa.Column('procedure_date', sa.DateTime(), nullable=False),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('procedure_type_concept_id', sa.Integer(), nullable=False),
sa.Column('procedure_source_value', sa.String(length=100), nullable=True),
sa.Column('procedure_occurrence_id', sa.Integer(), nullable=False),
sa.Column('associated_provider_id', sa.Integer(), nullable=True),
sa.Column('visit_occurrence_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['associated_provider_id'], [u'provider.provider_id'], name=op.f('fk_procedure_occurrence_associated_provider_id_provider')),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_procedure_occurrence_person_id_person')),
sa.ForeignKeyConstraint(['visit_occurrence_id'], [u'visit_occurrence.visit_occurrence_id'], name=op.f('fk_procedure_occurrence_visit_occurrence_id_visit_occurrence')),
sa.PrimaryKeyConstraint('procedure_occurrence_id', name=op.f('pk_procedure_occurrence'))
)
op.create_index(op.f('ix_procedure_occurrence_associated_provider_id'), 'procedure_occurrence', ['associated_provider_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_procedure_occurrence_person_id'), 'procedure_occurrence', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_procedure_occurrence_procedure_occurrence_id'), 'procedure_occurrence', ['procedure_occurrence_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_procedure_occurrence_visit_occurrence_id'), 'procedure_occurrence', ['visit_occurrence_id'], unique=False, postgresql_ops={})
op.create_table('condition_occurrence',
sa.Column('condition_concept_id', sa.Integer(), nullable=False),
sa.Column('condition_type_concept_id', sa.Integer(), nullable=False),
sa.Column('stop_reason', sa.String(length=100), nullable=True),
sa.Column('condition_start_date', sa.DateTime(), nullable=False),
sa.Column('condition_end_date', sa.DateTime(), nullable=True),
sa.Column('person_id', sa.Integer(), nullable=False),
sa.Column('condition_source_value', sa.String(length=100), nullable=True),
sa.Column('condition_occurrence_id', sa.Integer(), nullable=False),
sa.Column('associated_provider_id', sa.Integer(), nullable=True),
sa.Column('visit_occurrence_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['associated_provider_id'], [u'provider.provider_id'], name=op.f('fk_condition_occurrence_associated_provider_id_provider')),
sa.ForeignKeyConstraint(['person_id'], [u'person.person_id'], name=op.f('fk_condition_occurrence_person_id_person')),
sa.ForeignKeyConstraint(['visit_occurrence_id'], [u'visit_occurrence.visit_occurrence_id'], name=op.f('fk_condition_occurrence_visit_occurrence_id_visit_occurrence')),
sa.PrimaryKeyConstraint('condition_occurrence_id', name=op.f('pk_condition_occurrence'))
)
op.create_index(op.f('ix_condition_occurrence_associated_provider_id'), 'condition_occurrence', ['associated_provider_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_condition_occurrence_condition_occurrence_id'), 'condition_occurrence', ['condition_occurrence_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_condition_occurrence_person_id'), 'condition_occurrence', ['person_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_condition_occurrence_visit_occurrence_id'), 'condition_occurrence', ['visit_occurrence_id'], unique=False, postgresql_ops={})
op.create_table('procedure_cost',
sa.Column('total_out_of_pocket', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('revenue_code_source_value', sa.String(length=100), nullable=True),
sa.Column('paid_toward_deductible', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('revenue_code_concept_id', sa.Integer(), nullable=True),
sa.Column('payer_plan_period_id', sa.Integer(), nullable=True),
sa.Column('paid_by_payer', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('procedure_cost_id', sa.Integer(), nullable=False),
sa.Column('paid_copay', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('paid_coinsurance', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('paid_by_coordination_benefits', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('procedure_occurrence_id', sa.Integer(), nullable=False),
sa.Column('total_paid', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('disease_class_concept_id', sa.Integer(), nullable=True),
sa.Column('disease_class_source_value', sa.String(length=100), nullable=True),
sa.ForeignKeyConstraint(['payer_plan_period_id'], [u'payer_plan_period.payer_plan_period_id'], name=op.f('fk_procedure_cost_payer_plan_period_id_payer_plan_period')),
sa.ForeignKeyConstraint(['procedure_occurrence_id'], [u'procedure_occurrence.procedure_occurrence_id'], name=op.f('fk_procedure_cost_procedure_occurrence_id_procedure_occurrence')),
sa.PrimaryKeyConstraint('procedure_cost_id', name=op.f('pk_procedure_cost'))
)
op.create_index(op.f('ix_procedure_cost_payer_plan_period_id'), 'procedure_cost', ['payer_plan_period_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_procedure_cost_procedure_cost_id'), 'procedure_cost', ['procedure_cost_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_procedure_cost_procedure_occurrence_id'), 'procedure_cost', ['procedure_occurrence_id'], unique=False, postgresql_ops={})
op.create_table('drug_cost',
sa.Column('total_out_of_pocket', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('paid_toward_deductible', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('payer_plan_period_id', sa.Integer(), nullable=True),
sa.Column('drug_cost_id', sa.Integer(), nullable=False),
sa.Column('paid_by_payer', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('drug_exposure_id', sa.Integer(), nullable=False),
sa.Column('paid_copay', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('paid_coinsurance', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('paid_by_coordination_benefits', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('average_wholesale_price', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('ingredient_cost', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('total_paid', sa.Numeric(precision=8, scale=2), nullable=True),
sa.Column('dispensing_fee', sa.Numeric(precision=8, scale=2), nullable=True),
sa.ForeignKeyConstraint(['drug_exposure_id'], [u'drug_exposure.drug_exposure_id'], name=op.f('fk_drug_cost_drug_exposure_id_drug_exposure')),
sa.ForeignKeyConstraint(['payer_plan_period_id'], [u'payer_plan_period.payer_plan_period_id'], name=op.f('fk_drug_cost_payer_plan_period_id_payer_plan_period')),
sa.PrimaryKeyConstraint('drug_cost_id', name=op.f('pk_drug_cost'))
)
op.create_index(op.f('ix_drug_cost_drug_cost_id'), 'drug_cost', ['drug_cost_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_drug_cost_drug_exposure_id'), 'drug_cost', ['drug_exposure_id'], unique=False, postgresql_ops={})
op.create_index(op.f('ix_drug_cost_payer_plan_period_id'), 'drug_cost', ['payer_plan_period_id'], unique=False, postgresql_ops={})
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_drug_cost_payer_plan_period_id'), table_name='drug_cost')
op.drop_index(op.f('ix_drug_cost_drug_exposure_id'), table_name='drug_cost')
op.drop_index(op.f('ix_drug_cost_drug_cost_id'), table_name='drug_cost')
op.drop_table('drug_cost')
op.drop_index(op.f('ix_procedure_cost_procedure_occurrence_id'), table_name='procedure_cost')
op.drop_index(op.f('ix_procedure_cost_procedure_cost_id'), table_name='procedure_cost')
op.drop_index(op.f('ix_procedure_cost_payer_plan_period_id'), table_name='procedure_cost')
op.drop_table('procedure_cost')
op.drop_index(op.f('ix_condition_occurrence_visit_occurrence_id'), table_name='condition_occurrence')
op.drop_index(op.f('ix_condition_occurrence_person_id'), table_name='condition_occurrence')
op.drop_index(op.f('ix_condition_occurrence_condition_occurrence_id'), table_name='condition_occurrence')
op.drop_index(op.f('ix_condition_occurrence_associated_provider_id'), table_name='condition_occurrence')
op.drop_table('condition_occurrence')
op.drop_index(op.f('ix_procedure_occurrence_visit_occurrence_id'), table_name='procedure_occurrence')
op.drop_index(op.f('ix_procedure_occurrence_procedure_occurrence_id'), table_name='procedure_occurrence')
op.drop_index(op.f('ix_procedure_occurrence_person_id'), table_name='procedure_occurrence')
op.drop_index(op.f('ix_procedure_occurrence_associated_provider_id'), table_name='procedure_occurrence')
op.drop_table('procedure_occurrence')
op.drop_index(op.f('ix_drug_exposure_visit_occurrence_id'), table_name='drug_exposure')
op.drop_index(op.f('ix_drug_exposure_prescribing_provider_id'), table_name='drug_exposure')
op.drop_index(op.f('ix_drug_exposure_person_id'), table_name='drug_exposure')
op.drop_index(op.f('ix_drug_exposure_drug_exposure_id'), table_name='drug_exposure')
op.drop_table('drug_exposure')
op.drop_index(op.f('ix_observation_visit_occurrence_id'), table_name='observation')
op.drop_index(op.f('ix_observation_person_id_observation_concept_id'), table_name='observation')
op.drop_index(op.f('ix_observation_person_id'), table_name='observation')
op.drop_index(op.f('ix_observation_observation_id'), table_name='observation')
op.drop_index(op.f('ix_observation_associated_provider_id'), table_name='observation')
op.drop_table('observation')
op.drop_index(op.f('ix_condition_era_person_id'), table_name='condition_era')
op.drop_index(op.f('ix_condition_era_condition_era_id'), table_name='condition_era')
op.drop_table('condition_era')
op.drop_index(op.f('ix_observation_period_person_id_observation_period_start_date'), table_name='observation_period')
op.drop_index(op.f('ix_observation_period_person_id'), table_name='observation_period')
op.drop_index(op.f('ix_observation_period_observation_period_id'), table_name='observation_period')
op.drop_table('observation_period')
op.drop_index(op.f('ix_drug_era_person_id'), table_name='drug_era')
op.drop_index(op.f('ix_drug_era_drug_era_id'), table_name='drug_era')
op.drop_table('drug_era')
op.drop_index(op.f('ix_payer_plan_period_person_id'), table_name='payer_plan_period')
op.drop_index(op.f('ix_payer_plan_period_payer_plan_period_id'), table_name='payer_plan_period')
op.drop_table('payer_plan_period')
op.drop_index(op.f('ix_visit_occurrence_visit_occurrence_id'), table_name='visit_occurrence')
op.drop_index(op.f('ix_visit_occurrence_person_id_visit_start_date'), table_name='visit_occurrence')
op.drop_index(op.f('ix_visit_occurrence_person_id'), table_name='visit_occurrence')
op.drop_table('visit_occurrence')
op.drop_index(op.f('ix_death_person_id_death_type_concept_id_cause_of_death_concept_id'), table_name='death')
op.drop_index(op.f('ix_death_person_id'), table_name='death')
op.drop_table('death')
op.drop_index(op.f('ix_person_provider_id'), table_name='person')
op.drop_index(op.f('ix_person_person_id'), table_name='person')
op.drop_index(op.f('ix_person_location_id'), table_name='person')
op.drop_index(op.f('ix_person_care_site_id'), table_name='person')
op.drop_table('person')
op.drop_index(op.f('ix_provider_provider_id'), table_name='provider')
op.drop_index(op.f('ix_provider_care_site_id'), table_name='provider')
op.drop_table('provider')
op.drop_index(op.f('ix_care_site_organization_id'), table_name='care_site')
op.drop_index(op.f('ix_care_site_location_id'), table_name='care_site')
op.drop_index(op.f('ix_care_site_care_site_id'), table_name='care_site')
op.drop_table('care_site')
op.drop_index(op.f('ix_organization_organization_source_value_place_of_service_source_value'), table_name='organization')
op.drop_index(op.f('ix_organization_organization_id'), table_name='organization')
op.drop_index(op.f('ix_organization_location_id'), table_name='organization')
op.drop_table('organization')
op.drop_index(op.f('ix_cohort_cohort_id'), table_name='cohort')
op.drop_table('cohort')
op.drop_index(op.f('ix_location_location_id'), table_name='location')
op.drop_table('location')
### end Alembic commands ###
| PEDSnet/pedsnetcdms | pedsnetcdms/pedsnetcdm/alembic/versions/cfbd6d35cab_initial.py | Python | bsd-2-clause | 30,989 | 0.012101 |
# ------------------------------------
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# ------------------------------------
from azure.core.exceptions import ServiceRequestError
from azure.identity._internal.msal_client import MsalClient
import pytest
from helpers import mock, mock_response, validating_transport, Request
def test_retries_requests():
"""The client should retry token requests"""
message = "can't connect"
transport = mock.Mock(send=mock.Mock(side_effect=ServiceRequestError(message)))
client = MsalClient(transport=transport)
with pytest.raises(ServiceRequestError, match=message):
client.post("https://localhost")
assert transport.send.call_count > 1
transport.send.reset_mock()
with pytest.raises(ServiceRequestError, match=message):
client.get("https://localhost")
assert transport.send.call_count > 1
def test_get_error_response():
first_result = {"error": "first"}
first_response = mock_response(401, json_payload=first_result)
second_result = {"error": "second"}
second_response = mock_response(401, json_payload=second_result)
transport = validating_transport(
requests=[Request(url="https://localhost")] * 2, responses=[first_response, second_response]
)
client = MsalClient(transport=transport)
for result in (first_result, second_result):
assert not client.get_error_response(result)
client.get("https://localhost")
response = client.get_error_response(first_result)
assert response is first_response
client.post("https://localhost")
response = client.get_error_response(second_result)
assert response is second_response
assert not client.get_error_response(first_result)
| Azure/azure-sdk-for-python | sdk/identity/azure-identity/tests/test_msal_client.py | Python | mit | 1,769 | 0.001131 |
from pattern import Pattern
import copy
import numpy as np
import random
import collections
#from scipy.signal import convolve2d
import time
from collections import deque
class SpiralOutFast(Pattern):
def __init__(self):
self.register_param("r_leak", 0, 3, 1.2)
self.register_param("g_leak", 0, 3, 1.7)
self.register_param("b_leak", 0, 3, 2)
self.register_param("speed", 0, 1 , 0)
#Initialise time and color history
self.t = [0,0]
self.r = [0,0]
self.g = [0,0]
self.b = [0,0]
self.buff_len = 1500
self.start_time = np.float(time.time())
def on_pattern_select(self, octopus):
self.pixels = octopus.pixels_spiral()
self.previous_time = np.float16(time.time())
def next_frame(self, octopus, data):
current_time = time.time() - self.start_time
self.previous_time = current_time
scale = float(255)
self.t.append(current_time)
self.r.append(scale*np.mean([data.eq[0], data.eq[1]]))
self.g.append(scale*np.mean([data.eq[2], data.eq[3]]))
self.b.append(scale*np.mean([data.eq[4], data.eq[5], data.eq[6]]))
if len(self.t) > self.buff_len:
del self.t[0]
del self.r[0]
del self.g[0]
del self.b[0]
domain_r = np.linspace(current_time, current_time - self.r_leak, len(self.pixels))
domain_g = np.linspace(current_time, current_time - self.g_leak, len(self.pixels))
domain_b = np.linspace(current_time, current_time - self.b_leak, len(self.pixels))
r = np.interp(domain_r, self.t, self.r)
g = np.interp(domain_g, self.t, self.g)
b = np.interp(domain_b, self.t, self.b)
for i in range(len(self.pixels)):
self.pixels[i].color = (r[i], g[i], b[i])
| TheGentlemanOctopus/thegentlemanoctopus | octopus_code/core/octopus/patterns/spiralOutFast.py | Python | gpl-3.0 | 1,846 | 0.008667 |
# -*- coding: utf-8 -*-
import math
from kivy.uix.widget import Widget
from kivy.graphics import Color, Line
from kivy.vector import Vector
from kivy.properties import StringProperty, DictProperty, BooleanProperty, BoundedNumericProperty, ListProperty
class Painter(Widget):
tools = DictProperty({'arrow': {'color': (1, 1, 1, 1), 'thickness': 0.5},
'line': {'color': (1, 1, 1, 1), 'thickness': 0.5},
'freeline': {'color': (1, 1, 1, 1), 'thickness': 0.5},
'eraser': {'thickness': 0.4}
})
current_tool = StringProperty('arrow')
thickness = BoundedNumericProperty(1, min=0.5, max=10, errorvalue=0.5)
color = ListProperty((1, 1, 1, 1))
locked = BooleanProperty(False)
def on_thickness(self, instance, value):
self.tools[self.current_tool]['thickness'] = value
def on_color(self, instance, value):
self.tools[self.current_tool]['color'] = value
def on_current_tool(self, instance, value):
self.color = self.tools[value]['color']
self.thickness = self.tools[value]['thickness']
def on_touch_down(self, touch):
if not self.locked and self.collide_point(*touch.pos):
touch.grab(self)
with self.canvas:
Color(*self.color, mode='rgba')
touch.ud['line'] = Line(points=(touch.x, touch.y), width=self.thickness, cap='round', joint='miter')
if self.current_tool == 'arrow':
touch.ud['arrowhead'] = Line(width=self.thickness, cap='square', joint='miter')
touch.ud['initial_pos'] = touch.pos
else:
return False
return super(Painter, self).on_touch_down(touch)
def on_touch_move(self, touch):
if not self.locked and self.collide_point(*touch.pos):
try:
if self.current_tool == 'freeline':
touch.ud['line'].points += [touch.x, touch.y]
else:
touch.ud['line'].points = [touch.ox, touch.oy, touch.x, touch.y]
except KeyError:
pass
else:
return False
return super(Painter, self).on_touch_move(touch)
def arrowhead(self, start, end):
'''
start : list of points (x, y) for the start of the arrow.
end : list of points (x, y) for the end of the arrow.
return : list of points for each line forming the arrow head.
'''
# TODO: Adjust arrowhead size according to line thickness.
A = Vector(start)
B = Vector(end)
h = 10 * math.sqrt(3)
w = 10
U = (B - A) / Vector(B - A).length()
V = Vector(-U.y, U.x)
v1 = B - h * U + w * V
v2 = B - h * U - w * V
return (v1, v2)
def on_touch_up(self, touch):
if not self.locked and touch.grab_current == self and \
self.collide_point(*touch.pos) and self.current_tool == 'arrow':
try:
arrowhead = self.arrowhead(touch.ud['initial_pos'], touch.pos)
except KeyError:
pass
except ZeroDivisionError:
pass
else:
touch.ud['arrowhead'].points += arrowhead[0]
touch.ud['arrowhead'].points += (touch.x, touch.y)
touch.ud['arrowhead'].points += arrowhead[1]
touch.ungrab(self)
else:
return False
return super(Painter, self).on_touch_up(touch)
def on_size(self, *kwargs):
# TODO: Update every drawing according to size.
self.canvas.clear()
| octogene/hadaly | hadaly/painter.py | Python | gpl-3.0 | 3,680 | 0.00163 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.