content
stringlengths
7
928k
avg_line_length
float64
3.5
33.8k
max_line_length
int64
6
139k
alphanum_fraction
float64
0.08
0.96
licenses
list
repository_name
stringlengths
7
104
path
stringlengths
4
230
size
int64
7
928k
lang
stringclasses
1 value
import logging logger = logging.getLogger('spacel.provision.app.alarm.endpoint.factory') class AlarmEndpointFactory(object): def __init__(self, factories): self._factories = factories def add_endpoints(self, template, endpoints): endpoint_resources = {} logger.debug('Injecting %d endpoints.', len(endpoints)) for name, params in endpoints.items(): factory = self._factory_for_type(params, name) if not factory: continue actions = factory.add_endpoints(template, name, params) if actions: endpoint_resources[name] = { 'name': factory.resource_name(name), 'actions': actions } else: logger.debug('Endpoint %s was invalid.', name) if endpoint_resources: logger.debug('Built endpoints: %s', endpoint_resources) return endpoint_resources def _factory_for_type(self, params, name): endpoint_type = params.get('type') if not endpoint_type: logger.warning('Endpoint %s is missing "type".', name) return None factory = self._factories.get(endpoint_type) if not factory: logger.warning('Endpoint %s has invalid "type". Valid types: %s', name, sorted(self._factories.keys())) return None return factory
33.767442
77
0.587466
[ "MIT" ]
mycloudandme/spacel-provision
src/spacel/provision/app/alarm/endpoint/factory.py
1,452
Python
# encoding: utf-8 """ The *pathspec* package provides pattern matching for file paths. So far this only includes Git's wildmatch pattern matching (the style used for ".gitignore" files). The following classes are imported and made available from the root of the `pathspec` package: - :class:`pathspec.pathspec.PathSpec` - :class:`pathspec.pattern.Pattern` - :class:`pathspec.pattern.RegexPattern` - :class:`pathspec.util.RecursionError` The following functions are also imported: - :func:`pathspec.util.iter_tree` - :func:`pathspec.util.lookup_pattern` - :func:`pathspec.util.match_files` """ from __future__ import unicode_literals from .pathspec import PathSpec from .pattern import Pattern, RegexPattern from .util import iter_tree, lookup_pattern, match_files, RecursionError from ._meta import ( __author__, __copyright__, __credits__, __license__, __version__, ) # Load pattern implementations. from . import patterns # Expose `GitIgnorePattern` class in the root module for backward # compatibility with v0.4. from .patterns.gitwildmatch import GitIgnorePattern
24.659091
72
0.784332
[ "MIT" ]
AlexxyQQ/From-Moon-to-Earth
venv/Lib/site-packages/pathspec/__init__.py
1,085
Python
import pytest from django.core import mail from app.mail.owl import TemplOwl # type: ignore pytestmark = [pytest.mark.django_db] @pytest.fixture(autouse=True) def _enable_email(settings): settings.EMAIL_ENABLED = True @pytest.fixture def owl(): return TemplOwl( to='[email protected]', template_id=100500, ) def test_sending(owl): owl.send() assert len(mail.outbox) == 1 @pytest.mark.parametrize('switch', [ lambda settings: setattr(settings, 'EMAIL_ENABLED', False), ]) def test_kill_switch(owl, switch, settings): switch(settings) owl.send() assert len(mail.outbox) == 0 def test_attaching(owl): owl.attach(filename='testing_file_name_100500.txt', content=b'just testing') assert len(owl.msg.attachments) == 1 assert 'testing_file_name_100500.txt' in owl.msg.attachments[0]
19.295455
80
0.699647
[ "MIT" ]
Abdujabbar/education-backend
src/app/tests/owl/tests_owl_functional.py
849
Python
#!/usr/bin/python3 # ***************************************************************************** # # 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 argparse import os import sys from datalab.notebook_lib import * from fabric import * parser = argparse.ArgumentParser() parser.add_argument('--hostname', type=str, default='') parser.add_argument('--keyfile', type=str, default='') parser.add_argument('--os_user', type=str, default='') parser.add_argument('--application', type=str, default='') args = parser.parse_args() def general_clean(): try: conn.sudo('systemctl stop ungit') conn.sudo('systemctl stop inactive.timer') conn.sudo('rm -f /etc/systemd/system/inactive.service') conn.sudo('rm -f /etc/systemd/system/inactive.timer') conn.sudo('rm -rf /opt/inactivity') conn.sudo('npm -g uninstall ungit') conn.sudo('rm -f /etc/systemd/system/ungit.service') conn.sudo('systemctl daemon-reload') remove_os_pkg(['nodejs', 'npm']) conn.sudo('sed -i "/spark.*.memory/d" /opt/spark/conf/spark-defaults.conf') except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) def clean_jupyter(): try: conn.sudo('systemctl stop jupyter-notebook') conn.sudo('pip3 uninstall -y notebook jupyter') conn.sudo('rm -rf /usr/local/share/jupyter/') conn.sudo('rm -rf /home/{}/.jupyter/'.format(args.os_user)) conn.sudo('rm -rf /home/{}/.ipython/'.format(args.os_user)) conn.sudo('rm -rf /home/{}/.ipynb_checkpoints/'.format(args.os_user)) conn.sudo('rm -rf /home/{}/.local/share/jupyter/'.format(args.os_user)) conn.sudo('rm -f /etc/systemd/system/jupyter-notebook.service') conn.sudo('systemctl daemon-reload') except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) def clean_jupyterlab(): try: conn.sudo('systemctl stop jupyterlab-notebook') conn.sudo('pip3 uninstall -y jupyterlab') #conn.sudo('rm -rf /usr/local/share/jupyter/') conn.sudo('rm -rf /home/{}/.jupyter/'.format(args.os_user)) conn.sudo('rm -rf /home/{}/.ipython/'.format(args.os_user)) conn.sudo('rm -rf /home/{}/.ipynb_checkpoints/'.format(args.os_user)) conn.sudo('rm -rf /home/{}/.local/share/jupyter/'.format(args.os_user)) conn.sudo('rm -f /etc/systemd/system/jupyterlab-notebook.service') conn.sudo('systemctl daemon-reload') except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) def clean_zeppelin(): try: conn.sudo('systemctl stop zeppelin-notebook') conn.sudo('rm -rf /opt/zeppelin* /var/log/zeppelin /var/run/zeppelin') if os.environ['notebook_multiple_clusters'] == 'true': conn.sudo('systemctl stop livy-server') conn.sudo('rm -rf /opt/livy* /var/run/livy') conn.sudo('rm -f /etc/systemd/system/livy-server.service') conn.sudo('rm -f /etc/systemd/system/zeppelin-notebook.service') conn.sudo('systemctl daemon-reload') except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) def clean_rstudio(): try: remove_os_pkg(['rstudio-server']) conn.sudo('rm -f /home/{}/.Rprofile'.format(args.os_user)) conn.sudo('rm -f /home/{}/.Renviron'.format(args.os_user)) except Exception as err: print('Error:', str(err)) sys.exit(1) def clean_tensor(): try: clean_jupyter() conn.sudo('systemctl stop tensorboard') conn.sudo('systemctl disable tensorboard') conn.sudo('systemctl daemon-reload') except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) def clean_tensor_rstudio(): try: clean_rstudio() conn.sudo('systemctl stop tensorboard') conn.sudo('systemctl disable tensorboard') conn.sudo('systemctl daemon-reload') except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) def clean_tensor_jupyterlab(): try: clean_jupyterlab() conn.sudo('systemctl stop tensorboard') conn.sudo('systemctl disable tensorboard') conn.sudo('systemctl daemon-reload') except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) def clean_deeplearning(): try: conn.sudo('systemctl stop ungit') conn.sudo('systemctl stop inactive.timer') conn.sudo('rm -f /etc/systemd/system/inactive.service') conn.sudo('rm -f /etc/systemd/system/inactive.timer') conn.sudo('rm -rf /opt/inactivity') conn.sudo('npm -g uninstall ungit') conn.sudo('rm -f /etc/systemd/system/ungit.service') conn.sudo('systemctl daemon-reload') remove_os_pkg(['nodejs', 'npm']) conn.sudo('sed -i "/spark.*.memory/d" /opt/spark/conf/spark-defaults.conf') # conn.sudo('systemctl stop tensorboard') # conn.sudo('systemctl disable tensorboard') # conn.sudo('systemctl daemon-reload') clean_jupyter() except Exception as err: print('Error: {0}'.format(err)) sys.exit(1) if __name__ == "__main__": print('Configure connections') global conn conn = datalab.fab.init_datalab_connection(args.hostname, args.os_user, args.keyfile) if os.environ['conf_cloud_provider'] == 'azure': from datalab.actions_lib import ensure_right_mount_paths ensure_right_mount_paths() de_master_name = '{}-{}-{}-de-{}-m'.format( os.environ['conf_service_base_name'], os.environ['project_name'], os.environ['endpoint_name'], os.environ['computational_name']) de_ami_id = AzureMeta().get_instance_image(os.environ['azure_resource_group_name'], de_master_name) default_ami_id = 'default' else: de_master_name = '{}-{}-{}-de-{}-m'.format( os.environ['conf_service_base_name'], os.environ['project_name'], os.environ['endpoint_name'], os.environ['computational_name']) de_ami_id = get_ami_id_by_instance_name(de_master_name) default_ami_id = get_ami_id( os.environ['aws_{}_image_name'.format(os.environ['conf_os_family'])]) if de_ami_id != default_ami_id: if args.application in os.environ['dataengine_image_notebooks'].split(','): if args.application == 'deeplearning': clean_deeplearning() else: general_clean() if args.application == 'jupyter': clean_jupyter() elif args.application == 'zeppelin': clean_zeppelin() elif args.application == 'rstudio': clean_rstudio() elif args.application == 'tensor': clean_tensor() elif args.application == 'tensor-rstudio': clean_tensor_rstudio() elif args.application == 'tensor-jupyterlab': clean_tensor_jupyterlab() else: print('Found default ami, do not make clean') #conn.close() sys.exit(0)
38.657143
91
0.612343
[ "Apache-2.0" ]
pjfanning/incubator-datalab
infrastructure-provisioning/src/general/scripts/os/common_clean_instance.py
8,118
Python
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Mar 27 17:18:43 2020 @author: admangli """ import numpy as np import pandas as pd import matplotlib.pyplot as plt import math dataset = pd.read_csv('Ads_CTR_Optimisation.csv').values #%% slot_machines = 10 #%% Random ad selection reward import random random_reward = 0 for i in range(len(dataset)): random_reward += dataset[i, random.randint(0, slot_machines - 1)] #%% number_of_ad_selections = [0]*slot_machines reward_sums = [0]*slot_machines ad_selection_sequence = [] UCB_range = np.zeros((slot_machines, 2)) # To get an idea of underlying distributino # Generate initial seed, selecting each machine at least once randomly for round in range(0, slot_machines): target_ad = random.randint(0, slot_machines - 1) while (number_of_ad_selections[target_ad] == 1): target_ad = random.randint(0, slot_machines - 1) number_of_ad_selections[target_ad] += 1 reward_sums[target_ad] += dataset[round][target_ad] ad_selection_sequence.append(target_ad) for round in range(slot_machines, len(dataset)): # Calculate Ri and Delta for each ad for the current round Ri = [0]*slot_machines Deltai = [0]*slot_machines max_UCB = 0 target_ad = -1 for ad in range(0, slot_machines): Ri[ad] = reward_sums[ad] / number_of_ad_selections[ad] Deltai[ad] = math.sqrt(1.5 * math.log(round + 1)/number_of_ad_selections[ad]) UCB_range[ad, 0] = Ri[ad] + Deltai[ad] UCB_range[ad, 1] = Ri[ad] - Deltai[ad] if UCB_range[ad, 0] > max_UCB: # Pick the ad with maximum UCB = Ri + Delta for current round max_UCB = UCB_range[ad, 0] target_ad = ad # Increment selected ad's reward and number of selections if target_ad != -1: number_of_ad_selections[target_ad] += 1 reward_sums[target_ad] += dataset[round][target_ad] ad_selection_sequence.append(target_ad) #%% Visualize results # Plot a histogram showing how many times each ad was selected plt.hist(ad_selection_sequence) plt.xlabel('Ad Number') plt.ylabel('Number of selections') plt.title('Ad selection comparision') plt.show()
31
104
0.691504
[ "MIT" ]
adityamanglik/Algorithm-Implementations
Machine Learning/Sklearn Implementations/Reinforcement Learning/Upper_Confidence_Bound.py
2,201
Python
_base_ = [ '../_base_/models/icnet_r50-d8.py', '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py' ] model = dict( backbone=dict( resnet_cfg=dict( init_cfg=dict( type='Pretrained', checkpoint='open-mmlab://resnet50_v1c'))))
29.818182
77
0.615854
[ "Apache-2.0" ]
Junjun2016/ICNet
configs/icnet/icnet_r50-d8-pretrained_512x1024_160k_cityscapes.py
328
Python
import math import torch import torch.nn as nn import torch.nn.functional as F from .base import Loss class AdaCos(Loss): """PyTorch implementation of AdaCos. See Ref[1] for paper This implementation is different from the most open-source implementations in following ways: 1) expects raw logits of size (bs x num_classes) not (bs, embedding_size) 2) despite AdaCos being dynamic, still add an optional margin parameter 3) calculate running average stats of B and θ, not batch-wise stats as in original paper 4) normalize input logits, not embeddings and weights Args: margin (float): margin in radians momentum (float): momentum for running average of B and θ Input: y_pred (torch.Tensor): shape BS x N_classes y_true (torch.Tensor): one-hot encoded. shape BS x N_classes Reference: [1] Adaptively Scaling Cosine Logits for Effectively Learning Deep Face Representations """ def __init__(self, embedding_size, num_classes, final_criterion, margin=0, momentum=0.95): super(AdaCos, self).__init__() self.final_criterion = final_criterion self.margin = margin self.momentum = momentum self.prev_s = 10 self.running_B = 1000 # default value is chosen so that initial S is ~10 self.running_theta = math.pi / 4 self.eps = 1e-7 self.register_parameter("weight", torch.nn.Parameter(torch.zeros(num_classes, embedding_size))) nn.init.xavier_uniform_(self.weight) self.idx = 0 def forward(self, embedding, y_true): cos_theta = F.linear(F.normalize(embedding), F.normalize(self.weight)).clamp(-1 + self.eps, 1 - self.eps) # cos_theta = torch.cos(torch.acos(cos_theta + self.margin)) if y_true.dim() != 1: y_true_one_hot = y_true.float() else: y_true_one_hot = torch.zeros_like(cos_theta) y_true_one_hot.scatter_(1, y_true.unsqueeze(1), 1.0) with torch.no_grad(): B_batch = cos_theta[y_true_one_hot.eq(0)].mul(self.prev_s).exp().sum().div(embedding.size(0)) self.running_B = self.running_B * self.momentum + B_batch * (1 - self.momentum) theta = torch.acos(cos_theta.clamp(-1 + self.eps, 1 - self.eps)) # originally authors use median, but I use mean theta_batch = theta[y_true_one_hot.ne(0)].mean().clamp_max(math.pi / 4) self.running_theta = self.running_theta * self.momentum + theta_batch * (1 - self.momentum) self.prev_s = self.running_B.log() / torch.cos(self.running_theta) self.idx += 1 if self.idx % 1000 == 0: print( f"\nRunning B: {self.running_B:.2f}. Running theta: {self.running_theta:.2f}. Running S: {self.prev_s:.2f}" ) return self.final_criterion(cos_theta * self.prev_s, y_true_one_hot)
41.014085
123
0.655563
[ "MIT" ]
YevheniiSemendiak/pytorch-tools
pytorch_tools/losses/angular.py
2,914
Python
""" IGN Instituto Geográfico Nacional Sismología Feed. Fetches GeoRSS feed from IGN Instituto Geográfico Nacional Sismología. """ from datetime import datetime from typing import Optional import dateparser as dateparser from georss_client import FeedEntry, GeoRssFeed from georss_client.consts import CUSTOM_ATTRIBUTE from georss_client.feed_manager import FeedManagerBase ATTRIBUTION = "Instituto Geográfico Nacional" IMAGE_URL_PATTERN = ( "http://www.ign.es/web/resources/sismologia/www/" "dir_images_terremotos/detalle/{}.gif" ) REGEXP_ATTR_MAGNITUDE = r"magnitud (?P<{}>[^ ]+) ".format(CUSTOM_ATTRIBUTE) REGEXP_ATTR_REGION = r"magnitud [^ ]+ en (?P<{}>[A-ZÁÉÓÜÑ0-9 \-\.]+) en".format( CUSTOM_ATTRIBUTE ) REGEXP_ATTR_PUBLISHED_DATE = r"-Info.terremoto: (?P<{}>.+)$".format(CUSTOM_ATTRIBUTE) REGEXP_ATTR_SHORT_ID = ( r"http:\/\/www\.ign\.es\/web\/ign\/portal\/" r"sis-catalogo-terremotos\/-\/catalogo-terremotos\/" r"detailTerremoto\?evid=(?P<{}>\w+)$".format(CUSTOM_ATTRIBUTE) ) URL = "http://www.ign.es/ign/RssTools/sismologia.xml" class IgnSismologiaFeedManager(FeedManagerBase): """Feed Manager for IGN Sismología feed.""" def __init__( self, generate_callback, update_callback, remove_callback, coordinates, filter_radius=None, filter_minimum_magnitude=None, ): """Initialize the IGN Sismología Feed Manager.""" feed = IgnSismologiaFeed( coordinates, filter_radius=filter_radius, filter_minimum_magnitude=filter_minimum_magnitude, ) super().__init__(feed, generate_callback, update_callback, remove_callback) class IgnSismologiaFeed(GeoRssFeed): """IGN Sismología feed.""" def __init__( self, home_coordinates, filter_radius=None, filter_minimum_magnitude=None ): """Initialise this service.""" super().__init__(home_coordinates, URL, filter_radius=filter_radius) self._filter_minimum_magnitude = filter_minimum_magnitude def __repr__(self): """Return string representation of this feed.""" return "<{}(home={}, url={}, radius={}, magnitude={})>".format( self.__class__.__name__, self._home_coordinates, self._url, self._filter_radius, self._filter_minimum_magnitude, ) def _new_entry(self, home_coordinates, rss_entry, global_data): """Generate a new entry.""" return IgnSismologiaFeedEntry(home_coordinates, rss_entry) def _filter_entries(self, entries): """Filter the provided entries.""" entries = super()._filter_entries(entries) if self._filter_minimum_magnitude: # Return only entries that have an actual magnitude value, and # the value is equal or above the defined threshold. return list( filter( lambda entry: entry.magnitude and entry.magnitude >= self._filter_minimum_magnitude, entries, ) ) return entries class IgnSismologiaFeedEntry(FeedEntry): """IGN Sismología feed entry.""" def __init__(self, home_coordinates, rss_entry): """Initialise this service.""" super().__init__(home_coordinates, rss_entry) @property def attribution(self) -> str: """Return the attribution of this entry.""" return ATTRIBUTION @property def published(self) -> Optional[datetime]: """Return the published date of this entry.""" published_date = self._search_in_title(REGEXP_ATTR_PUBLISHED_DATE) if published_date: published_date = dateparser.parse(published_date) return published_date @property def magnitude(self) -> Optional[float]: """Return the magnitude of this entry.""" magnitude = self._search_in_description(REGEXP_ATTR_MAGNITUDE) if magnitude: magnitude = float(magnitude) return magnitude @property def region(self) -> Optional[float]: """Return the region of this entry.""" return self._search_in_description(REGEXP_ATTR_REGION) def _short_id(self) -> Optional[str]: """Return the short id of this entry.""" return self._search_in_external_id(REGEXP_ATTR_SHORT_ID) @property def image_url(self) -> Optional[str]: """Return the image url of this entry.""" short_id = self._short_id() if short_id: return IMAGE_URL_PATTERN.format(short_id) return None
33.035714
85
0.65773
[ "Apache-2.0" ]
exxamalte/python-georss-ign-sismologia-client
georss_ign_sismologia_client/__init__.py
4,639
Python
lista = [1,2,3,4,5] for i in range(0,5): print(lista[i])
16.25
20
0.523077
[ "MIT" ]
jwellington58/Wellingtonlp220172vacation
Wellington_python/exemplo_listas.py
65
Python
''' convenience functions for ANOVA type analysis with OLS Note: statistical results of ANOVA are not checked, OLS is checked but not whether the reported results are the ones used in ANOVA includes form2design for creating dummy variables TODO: * ... * ''' import numpy as np #from scipy import stats import statsmodels.api as sm def data2dummy(x, returnall=False): '''convert array of categories to dummy variables by default drops dummy variable for last category uses ravel, 1d only''' x = x.ravel() groups = np.unique(x) if returnall: return (x[:, None] == groups).astype(int) else: return (x[:, None] == groups).astype(int)[:,:-1] def data2proddummy(x): '''creates product dummy variables from 2 columns of 2d array drops last dummy variable, but not from each category singular with simple dummy variable but not with constant quickly written, no safeguards ''' #brute force, assumes x is 2d #replace with encoding if possible groups = np.unique(map(tuple, x.tolist())) #includes singularity with additive factors return (x==groups[:,None,:]).all(-1).T.astype(int)[:,:-1] def data2groupcont(x1,x2): '''create dummy continuous variable Parameters ---------- x1 : 1d array label or group array x2 : 1d array (float) continuous variable Notes ----- useful for group specific slope coefficients in regression ''' if x2.ndim == 1: x2 = x2[:,None] dummy = data2dummy(x1, returnall=True) return dummy * x2 # Result strings #the second leaves the constant in, not with NIST regression #but something fishy with res.ess negative in examples ? #not checked if these are all the right ones anova_str0 = ''' ANOVA statistics (model sum of squares excludes constant) Source DF Sum Squares Mean Square F Value Pr > F Model %(df_model)i %(ess)f %(mse_model)f %(fvalue)f %(f_pvalue)f Error %(df_resid)i %(ssr)f %(mse_resid)f CTotal %(nobs)i %(uncentered_tss)f %(mse_total)f R squared %(rsquared)f ''' anova_str = ''' ANOVA statistics (model sum of squares includes constant) Source DF Sum Squares Mean Square F Value Pr > F Model %(df_model)i %(ssmwithmean)f %(mse_model)f %(fvalue)f %(f_pvalue)f Error %(df_resid)i %(ssr)f %(mse_resid)f CTotal %(nobs)i %(uncentered_tss)f %(mse_total)f R squared %(rsquared)f ''' def anovadict(res): '''update regression results dictionary with ANOVA specific statistics not checked for completeness ''' ad = {} ad.update(res.__dict__) #dict doesn't work with cached attributes anova_attr = ['df_model', 'df_resid', 'ess', 'ssr','uncentered_tss', 'mse_model', 'mse_resid', 'mse_total', 'fvalue', 'f_pvalue', 'rsquared'] for key in anova_attr: ad[key] = getattr(res, key) ad['nobs'] = res.model.nobs ad['ssmwithmean'] = res.uncentered_tss - res.ssr return ad def form2design(ss, data): '''convert string formula to data dictionary ss : string * I : add constant * varname : for simple varnames data is used as is * F:varname : create dummy variables for factor varname * P:varname1*varname2 : create product dummy variables for varnames * G:varname1*varname2 : create product between factor and continuous variable data : dict or structured array data set, access of variables by name as in dictionaries Returns ------- vars : dictionary dictionary of variables with converted dummy variables names : list list of names, product (P:) and grouped continuous variables (G:) have name by joining individual names sorted according to input Examples -------- >>> xx, n = form2design('I a F:b P:c*d G:c*f', testdata) >>> xx.keys() ['a', 'b', 'const', 'cf', 'cd'] >>> n ['const', 'a', 'b', 'cd', 'cf'] Notes ----- with sorted dict, separate name list wouldn't be necessary ''' vars = {} names = [] for item in ss.split(): if item == 'I': vars['const'] = np.ones(data.shape[0]) names.append('const') elif not ':' in item: vars[item] = data[item] names.append(item) elif item[:2] == 'F:': v = item.split(':')[1] vars[v] = data2dummy(data[v]) names.append(v) elif item[:2] == 'P:': v = item.split(':')[1].split('*') vars[''.join(v)] = data2proddummy(np.c_[data[v[0]],data[v[1]]]) names.append(''.join(v)) elif item[:2] == 'G:': v = item.split(':')[1].split('*') vars[''.join(v)] = data2groupcont(data[v[0]], data[v[1]]) names.append(''.join(v)) else: raise ValueError('unknown expression in formula') return vars, names def dropname(ss, li): '''drop names from a list of strings, names to drop are in space delimeted list does not change original list ''' newli = li[:] for item in ss.split(): newli.remove(item) return newli if __name__ == '__main__': # Test Example with created data # ------------------------------ nobs = 1000 testdataint = np.random.randint(3, size=(nobs,4)).view([('a',int),('b',int),('c',int),('d',int)]) testdatacont = np.random.normal( size=(nobs,2)).view([('e',float), ('f',float)]) import numpy.lib.recfunctions dt2 = numpy.lib.recfunctions.zip_descr((testdataint, testdatacont),flatten=True) # concatenate structured arrays testdata = np.empty((nobs,1), dt2) for name in testdataint.dtype.names: testdata[name] = testdataint[name] for name in testdatacont.dtype.names: testdata[name] = testdatacont[name] #print form2design('a',testdata) if 0: # print only when nobs is small, e.g. nobs=10 xx, n = form2design('F:a',testdata) print xx print form2design('P:a*b',testdata) print data2proddummy((np.c_[testdata['a'],testdata['b']])) xx, names = form2design('a F:b P:c*d',testdata) #xx, names = form2design('I a F:b F:c F:d P:c*d',testdata) xx, names = form2design('I a F:b P:c*d', testdata) xx, names = form2design('I a F:b P:c*d G:a*e f', testdata) X = np.column_stack([xx[nn] for nn in names]) # simple test version: all coefficients equal to one y = X.sum(1) + 0.01*np.random.normal(size=(nobs)) rest1 = sm.OLS(y,X).fit() #results print rest1.params print anova_str % anovadict(rest1) X = np.column_stack([xx[nn] for nn in dropname('ae f', names)]) # simple test version: all coefficients equal to one y = X.sum(1) + 0.01*np.random.normal(size=(nobs)) rest1 = sm.OLS(y,X).fit() print rest1.params print anova_str % anovadict(rest1) # Example: from Bruce # ------------------- #get data and clean it #^^^^^^^^^^^^^^^^^^^^^ # requires file 'dftest3.data' posted by Bruce # read data set and drop rows with missing data dt_b = np.dtype([('breed', int), ('sex', int), ('litter', int), ('pen', int), ('pig', int), ('age', float), ('bage', float), ('y', float)]) dta = np.genfromtxt('dftest3.data', dt_b,missing='.', usemask=True) print 'missing', [dta.mask[k].sum() for k in dta.dtype.names] m = dta.mask.view(bool) droprows = m.reshape(-1,len(dta.dtype.names)).any(1) # get complete data as plain structured array # maybe doesn't work with masked arrays dta_use_b1 = dta[~droprows,:].data print dta_use_b1.shape print dta_use_b1.dtype #Example b1: variables from Bruce's glm #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # prepare data and dummy variables xx_b1, names_b1 = form2design('I F:sex age', dta_use_b1) # create design matrix X_b1 = np.column_stack([xx_b1[nn] for nn in dropname('', names_b1)]) y_b1 = dta_use_b1['y'] # estimate using OLS rest_b1 = sm.OLS(y_b1, X_b1).fit() # print results print rest_b1.params print anova_str % anovadict(rest_b1) #compare with original version only in original version #print anova_str % anovadict(res_b0) # Example: use all variables except pig identifier #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ allexog = ' '.join(dta.dtype.names[:-1]) #'breed sex litter pen pig age bage' xx_b1a, names_b1a = form2design('I F:breed F:sex F:litter F:pen age bage', dta_use_b1) X_b1a = np.column_stack([xx_b1a[nn] for nn in dropname('', names_b1a)]) y_b1a = dta_use_b1['y'] rest_b1a = sm.OLS(y_b1a, X_b1a).fit() print rest_b1a.params print anova_str % anovadict(rest_b1a) for dropn in names_b1a: print '\nResults dropping', dropn X_b1a_ = np.column_stack([xx_b1a[nn] for nn in dropname(dropn, names_b1a)]) y_b1a_ = dta_use_b1['y'] rest_b1a_ = sm.OLS(y_b1a_, X_b1a_).fit() #print rest_b1a_.params print anova_str % anovadict(rest_b1a_)
31.774306
101
0.605289
[ "BSD-3-Clause" ]
AnaMP/statsmodels
statsmodels/sandbox/regression/try_ols_anova.py
9,151
Python
from lxml import objectify from kloppy.domain import Period, PitchDimensions, Dimension from kloppy.infra.utils import Readable from .models import * def noop(x): return x def _load_provider_parameters(parent_elm, value_mapper=None) -> Dict: if parent_elm is None: return {} if not value_mapper: value_mapper = noop return { str(param.find('Name')): value_mapper(param.find('Value')) for param in parent_elm.iterchildren(tag='ProviderParameter') if param.find('Value') != '' } def _load_periods(global_config_elm, frame_rate: int) -> List[Period]: provider_params = _load_provider_parameters( global_config_elm.find('ProviderGlobalParameters'), value_mapper=int ) period_names = ['first_half', 'second_half', 'first_extra_half', 'second_extra_half'] periods = [] for idx, period_name in enumerate(period_names): start_key = f"{period_name}_start" end_key = f"{period_name}_end" if start_key in provider_params: periods.append( Period( id=idx + 1, start_timestamp=float(provider_params[start_key]) / frame_rate, end_timestamp=float(provider_params[end_key]) / frame_rate ) ) else: # done break return periods def _load_players(players_elm, team_map: Dict[str, Team]) -> List[Player]: return [ Player( team=team_map[player_elm.attrib['teamId']], jersey_no=str(player_elm.find('ShirtNumber')), player_id=player_elm.attrib['id'], name=str(player_elm.find('Name')), attributes=_load_provider_parameters(players_elm.find('ProviderPlayerParameters')) ) for player_elm in players_elm.iterchildren(tag='Player') ] def _load_data_format_specifications(data_format_specifications_elm) -> List[DataFormatSpecification]: return [ DataFormatSpecification.from_xml_element(data_format_specification_elm) for data_format_specification_elm in data_format_specifications_elm.iterchildren(tag='DataFormatSpecification') ] def _load_sensors(sensors_elm) -> List[Sensor]: return [ Sensor.from_xml_element(sensor_elm) for sensor_elm in sensors_elm.iterchildren(tag="Sensor") ] def _load_pitch_dimensions(meta_data_elm, sensors: List[Sensor]) -> Union[None, PitchDimensions]: normalized = False for sensor in sensors: if sensor.sensor_id == 'position': if sensor.channels[0].unit == 'normalized': normalized = True break field_size_path = objectify.ObjectPath("Metadata.Sessions.Session[0]") field_size_elm = field_size_path.find(meta_data_elm).find('FieldSize') if field_size_elm is not None and normalized: return PitchDimensions( x_dim=Dimension(0, 1), y_dim=Dimension(0, 1), x_per_meter=1 / int(field_size_elm.find('Width')), y_per_meter=1 / int(field_size_elm.find('Height')) ) else: return None def load_meta_data(meta_data_file: Readable) -> EPTSMetaData: root = objectify.fromstring(meta_data_file.read()) meta_data = root.find('Metadata') score_path = objectify.ObjectPath("Metadata.Sessions.Session[0].MatchParameters.Score") score_elm = score_path.find(meta_data) _team_map = { score_elm.attrib['idLocalTeam']: Team.HOME, score_elm.attrib['idVisitingTeam']: Team.AWAY } players = _load_players(meta_data.find('Players'), _team_map) data_format_specifications = _load_data_format_specifications(root.find('DataFormatSpecifications')) device_path = objectify.ObjectPath("Metadata.Devices.Device[0].Sensors") sensors = _load_sensors(device_path.find(meta_data)) _channel_map = { channel.channel_id: channel for sensor in sensors for channel in sensor.channels } _player_map = { player.player_id: player for player in players } player_channels = [ PlayerChannel( player_channel_id=player_channel_elm.attrib['id'], player=_player_map[player_channel_elm.attrib['playerId']], channel=_channel_map[player_channel_elm.attrib['channelId']] ) for player_channel_elm in meta_data.find('PlayerChannels').iterchildren(tag='PlayerChannel') ] team_name_map = { _team_map[team_elm.attrib['id']]: str(team_elm.find('Name')) for team_elm in meta_data.find('Teams').iterchildren(tag='Team') } frame_rate = int(meta_data.find('GlobalConfig').find('FrameRate')) periods = _load_periods(meta_data.find('GlobalConfig'), frame_rate) pitch_dimensions = _load_pitch_dimensions(meta_data, sensors) return EPTSMetaData( home_team_name=team_name_map[Team.HOME], away_team_name=team_name_map[Team.AWAY], players=players, periods=periods, pitch_dimensions=pitch_dimensions, data_format_specifications=data_format_specifications, player_channels=player_channels, frame_rate=frame_rate, sensors=sensors )
32.140244
104
0.667046
[ "BSD-3-Clause" ]
dmallory42/kloppy
kloppy/infra/serializers/tracking/epts/meta_data.py
5,271
Python
# Copyright 2020 Konstruktor, Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import click from tethys.apps.base import AppBase @click.group() def cli(): """ The tethys CLI for managing your environment. """ @cli.group(name="apps") def apps_entry(): """ Tethys apps manager """ for app_cls in AppBase.get_apps(): add_click_entry = getattr(app_cls, "add_click_entry", None) if add_click_entry: add_click_entry(apps_entry)
26.864865
74
0.72334
[ "ECL-2.0", "Apache-2.0" ]
tethys-platform/tethys
tethys/bin/cli.py
994
Python
""" This code was taken from https://github.com/ActiveState/appdirs and modified to suite our purposes. """ import os import sys from pip._vendor import six def user_cache_dir(appname): r""" Return full path to the user-specific cache dir for this application. "appname" is the name of application. Typical user cache directories are: Mac OS X: ~/Library/Caches/<AppName> Unix: ~/.cache/<AppName> (XDG default) Windows: C:\Users\<username>\AppData\Local\<AppName>\Cache On Windows the only suggestion in the MSDN docs is that local settings go in the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming app data dir (the default returned by `user_data_dir`). Apps typically put cache data somewhere *under* the given dir here. Some examples: ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache ...\Acme\SuperApp\Cache\1.0 OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value. """ if sys.platform == "win32": # Get the base path path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA")) # Add our app name and Cache directory to it path = os.path.join(path, appname, "Cache") elif sys.platform == "darwin": # Get the base path path = os.path.expanduser("~/Library/Caches") # Add our app name to it path = os.path.join(path, appname) else: # Get the base path path = os.getenv("XDG_CACHE_HOME", os.path.expanduser("~/.cache")) # Add our app name to it path = os.path.join(path, appname) return path # -- Windows support functions -- def _get_win_folder_from_registry(csidl_name): """ This is a fallback technique at best. I'm not sure if using the registry for this guarantees us the correct answer for all CSIDL_* names. """ import _winreg shell_folder_name = { "CSIDL_APPDATA": "AppData", "CSIDL_COMMON_APPDATA": "Common AppData", "CSIDL_LOCAL_APPDATA": "Local AppData", }[csidl_name] key = _winreg.OpenKey( _winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" ) directory, _type = _winreg.QueryValueEx(key, shell_folder_name) return directory def _get_win_folder_with_pywin32(csidl_name): from win32com.shell import shellcon, shell directory = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0) # Try to make this a unicode path because SHGetFolderPath does # not return unicode strings when there is unicode data in the # path. try: directory = six.text_type(directory) # Downgrade to short path name if have highbit chars. See # <http://bugs.activestate.com/show_bug.cgi?id=85099>. has_high_char = False for c in directory: if ord(c) > 255: has_high_char = True break if has_high_char: try: import win32api directory = win32api.GetShortPathName(directory) except ImportError: pass except UnicodeError: pass return directory def _get_win_folder_with_ctypes(csidl_name): csidl_const = { "CSIDL_APPDATA": 26, "CSIDL_COMMON_APPDATA": 35, "CSIDL_LOCAL_APPDATA": 28, }[csidl_name] buf = ctypes.create_unicode_buffer(1024) ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf) # Downgrade to short path name if have highbit chars. See # <http://bugs.activestate.com/show_bug.cgi?id=85099>. has_high_char = False for c in buf: if ord(c) > 255: has_high_char = True break if has_high_char: buf2 = ctypes.create_unicode_buffer(1024) if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024): buf = buf2 return buf.value if sys.platform == "win32": try: import win32com.shell # noqa _get_win_folder = _get_win_folder_with_pywin32 except ImportError: try: import ctypes _get_win_folder = _get_win_folder_with_ctypes except ImportError: _get_win_folder = _get_win_folder_from_registry
31.136691
78
0.647874
[ "MIT" ]
chadrik/pip
pip/appdirs.py
4,328
Python
import os AWS_ACCESS_KEY_ID_PERF = os.environ['AWS_ACCESS_KEY_ID_PERF'] AWS_SECRET_ACCESS_KEY_PERF = os.environ['AWS_SECRET_ACCESS_KEY_PERF'] AWS_ACCESS_KEY_ID_DELETE_PERF = os.environ['AWS_ACCESS_KEY_ID_DELETE_PERF'] AWS_SECRET_ACCESS_KEY_DELETE_PERF = os.environ['AWS_SECRET_ACCESS_KEY_DELETE_PERF'] BUCKET_PERF = os.environ['BUCKET_PERF'] AWS_ACCESS_KEY_ID_PSAP = os.environ['AWS_ACCESS_KEY_ID_PSAP'] AWS_SECRET_ACCESS_KEY_PSAP = os.environ['AWS_SECRET_ACCESS_KEY_PSAP'] BUCKET_PSAP = os.environ['BUCKET_PSAP'] AWS_ACCESS_KEY_ID_RH_PERF = os.environ['AWS_ACCESS_KEY_ID_RH_PERF'] AWS_SECRET_ACCESS_KEY_RH_PERF = os.environ['AWS_SECRET_ACCESS_KEY_RH_PERF'] BUCKET_RH_PERF = os.environ['BUCKET_RH_PERF'] GITHUB_TOKEN = os.environ['GITHUB_TOKEN'] LOGS = os.environ.get('LOGS', 'logs') mandatory_tags = {'Budget': 'PERF-DEPT'} print('Run all policies pre active region') regions = ['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2', 'eu-central-1', 'ap-south-1', 'eu-north-1', 'ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-west-3', 'sa-east-1'] for region in regions: os.system(f"""sudo podman run --rm --name cloud-governance-tagging -e account='perf' -e policy=tag_resources -e AWS_ACCESS_KEY_ID={AWS_ACCESS_KEY_ID_DELETE_PERF} -e AWS_SECRET_ACCESS_KEY={AWS_SECRET_ACCESS_KEY_DELETE_PERF} -e AWS_DEFAULT_REGION={region} -e tag_operation=update -e mandatory_tags="{mandatory_tags}" -e log_level=INFO -v /etc/localtime:/etc/localtime quay.io/ebattat/cloud-governance:latest""")
59.92
413
0.789052
[ "Apache-2.0" ]
athiruma/cloud-governance
jenkins/tagging/tagging.py
1,498
Python
from movies.settings import *
15
29
0.8
[ "MIT" ]
Wonqu/rz_movies
app/movies/settings/settings_dev.py
30
Python
# https://github.com/theeko74/pdfc # modified by brio50 on 2022/01/23, working with gs version 9.54.0 """ Simple python wrapper script to use ghoscript function to compress PDF files. Compression levels: 0: default 1: prepress 2: printer 3: ebook 4: screen Dependency: Ghostscript. On MacOSX install via command line `brew install ghostscript`. """ import argparse import subprocess import os.path import sys import shutil def compress(input_file_path, output_file_path, level=0, method=1): """Function to compress PDF via Ghostscript command line interface""" quality = { 0: '/default', 1: '/prepress', 2: '/printer', 3: '/ebook', 4: '/screen' } # Check if valid path if not os.path.isfile(input_file_path): print(f"Error: invalid path for input file: {input_file_path}") sys.exit(1) # Check if file is a PDF by extension if input_file_path.split('.')[-1].lower() != 'pdf': # not sure this is the most robust solution print(f"Error: input file is not a PDF: {input_file_path}") sys.exit(1) gs = get_ghostscript_path() file_name = input_file_path.split('/')[-1] # everything after last '/' print("Compressing PDF \"{}\"...".format(file_name)) if method == 1: # https://gist.github.com/lkraider/f0888da30bc352f9d167dfa4f4fc8213 cmd = [gs, '-sDEVICE=pdfwrite', '-dNumRenderingThreads=2', '-dPDFSETTINGS={}'.format(quality[level]), '-dCompatibilityLevel=1.5', '-dNOPAUSE', '-dQUIET', '-dBATCH', '-dSAFER', # font settings '-dSubsetFonts=true', '-dCompressFonts=true', '-dEmbedAllFonts=true', # color format` '-sProcessColorModel=DeviceRGB', '-sColorConversionStrategy=RGB', '-sColorConversionStrategyForImages=RGB', '-dConvertCMYKImagesToRGB=true', # image resample '-dDetectDuplicateImages=true', '-dColorImageDownsampleType=/Bicubic', '-dColorImageResolution=300', '-dGrayImageDownsampleType=/Bicubic', '-dGrayImageResolution=300', '-dMonoImageDownsampleType=/Subsample', '-dMonoImageResolution=300', '-dDownsampleColorImages=true', # preset overrides '-dDoThumbnails=false', '-dCreateJobTicket=false', '-dPreserveEPSInfo=false', '-dPreserveOPIComments=false', '-dPreserveOverprintSettings=false', '-dUCRandBGInfo=/Remove', '-sOutputFile={}'.format(output_file_path), input_file_path] elif method == 2: cmd = [gs, '-sDEVICE=pdfwrite', '-dNumRenderingThreads=2', '-dPDFSETTINGS={}'.format(quality[level]), '-dCompatibilityLevel=1.4', '-dNOPAUSE', '-dQUIET', '-dBATCH', '-dSAFER', '-dDetectDuplicateImages=true', '-sOutputFile={}'.format(output_file_path), input_file_path] try: # execute subprocess.call(cmd, stderr=sys.stdout) except: # print ghostscript command for debug print(" ".join(cmd)) if not os.path.exists(output_file_path): raise Exception(f"Ghostscript failed to create {output_file_path}, time to debug...\n", " ".join(cmd)) initial_size = round(os.path.getsize(input_file_path) / (1024 * 1024), 2) final_size = round(os.path.getsize(output_file_path) / (1024 * 1024), 2) ratio = round(100 - ((final_size / initial_size) * 100), 1) print(f"Initial file size is {initial_size}MB", f"; Final file size is {final_size}MB", f"; Compression Ratio = {ratio}%\n") if final_size > initial_size and method == 1: print('-' * 100) print('Compression Failed\nTrying another ghostscript compression method...') print('-' * 100) info = compress(input_file_path, output_file_path, 4, 2) initial_size = info[0] final_size = info[1] ratio = info[2] return [initial_size, final_size, ratio] def get_ghostscript_path(): gs_names = ['gs', 'gswin32', 'gswin64'] for name in gs_names: if shutil.which(name): return shutil.which(name) raise FileNotFoundError(f'No GhostScript executable was found on path ({"/".join(gs_names)})') def main(): parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter ) parser.add_argument('input', help='Relative or absolute path of the input PDF file') parser.add_argument('-o', '--out', help='Relative or absolute path of the output PDF file') parser.add_argument('-c', '--compress', type=int, help='Compression level from 0 to 4') parser.add_argument('-b', '--backup', action='store_true', help="Backup the old PDF file") parser.add_argument('--open', action='store_true', default=False, help='Open PDF after compression') args = parser.parse_args() # In case no compression level is specified, default is 2 '/ printer' if not args.compress: args.compress = 2 # In case no output file is specified, store in temp file if not args.out: args.out = 'temp.pdf' # Run compress(args.input, args.out, power=args.compress) # In case no output file is specified, erase original file if args.out == 'temp.pdf': if args.backup: shutil.copyfile(args.input, args.input.replace(".pdf", "_BACKUP.pdf")) shutil.copyfile(args.out, args.input) os.remove(args.out) # In case we want to open the file after compression if args.open: if args.out == 'temp.pdf' and args.backup: subprocess.call(['open', args.input]) else: subprocess.call(['open', args.out]) if __name__ == '__main__': main()
35.598837
100
0.600033
[ "MIT" ]
brio50/groups-io
gs_compress.py
6,123
Python
# -*- coding: utf-8 -*- # Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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 collections import OrderedDict from distutils import util import os import re from typing import Dict, Optional, Sequence, Tuple, Type, Union import pkg_resources from google.api_core import client_options as client_options_lib # type: ignore from google.api_core import exceptions as core_exceptions # type: ignore from google.api_core import gapic_v1 # type: ignore from google.api_core import retry as retries # type: ignore from google.auth import credentials as ga_credentials # type: ignore from google.auth.transport import mtls # type: ignore from google.auth.transport.grpc import SslCredentials # type: ignore from google.auth.exceptions import MutualTLSChannelError # type: ignore from google.oauth2 import service_account # type: ignore from google.api import httpbody_pb2 # type: ignore from google.api_core import operation # type: ignore from google.api_core import operation_async # type: ignore from google.cloud.recommendationengine_v1beta1.services.user_event_service import pagers from google.cloud.recommendationengine_v1beta1.types import import_ from google.cloud.recommendationengine_v1beta1.types import user_event from google.cloud.recommendationengine_v1beta1.types import user_event as gcr_user_event from google.cloud.recommendationengine_v1beta1.types import user_event_service from google.protobuf import any_pb2 # type: ignore from google.protobuf import timestamp_pb2 # type: ignore from .transports.base import UserEventServiceTransport, DEFAULT_CLIENT_INFO from .transports.grpc import UserEventServiceGrpcTransport from .transports.grpc_asyncio import UserEventServiceGrpcAsyncIOTransport class UserEventServiceClientMeta(type): """Metaclass for the UserEventService client. This provides class-level methods for building and retrieving support objects (e.g. transport) without polluting the client instance objects. """ _transport_registry = OrderedDict() # type: Dict[str, Type[UserEventServiceTransport]] _transport_registry["grpc"] = UserEventServiceGrpcTransport _transport_registry["grpc_asyncio"] = UserEventServiceGrpcAsyncIOTransport def get_transport_class(cls, label: str = None, ) -> Type[UserEventServiceTransport]: """Returns an appropriate transport class. Args: label: The name of the desired transport. If none is provided, then the first transport in the registry is used. Returns: The transport class to use. """ # If a specific transport is requested, return that one. if label: return cls._transport_registry[label] # No transport is requested; return the default (that is, the first one # in the dictionary). return next(iter(cls._transport_registry.values())) class UserEventServiceClient(metaclass=UserEventServiceClientMeta): """Service for ingesting end user actions on the customer website. """ @staticmethod def _get_default_mtls_endpoint(api_endpoint): """Converts api endpoint to mTLS endpoint. Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively. Args: api_endpoint (Optional[str]): the api endpoint to convert. Returns: str: converted mTLS api endpoint. """ if not api_endpoint: return api_endpoint mtls_endpoint_re = re.compile( r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?" ) m = mtls_endpoint_re.match(api_endpoint) name, mtls, sandbox, googledomain = m.groups() if mtls or not googledomain: return api_endpoint if sandbox: return api_endpoint.replace( "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" ) return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") DEFAULT_ENDPOINT = "recommendationengine.googleapis.com" DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__( # type: ignore DEFAULT_ENDPOINT ) @classmethod def from_service_account_info(cls, info: dict, *args, **kwargs): """Creates an instance of this client using the provided credentials info. Args: info (dict): The service account private key info. args: Additional arguments to pass to the constructor. kwargs: Additional arguments to pass to the constructor. Returns: UserEventServiceClient: The constructed client. """ credentials = service_account.Credentials.from_service_account_info(info) kwargs["credentials"] = credentials return cls(*args, **kwargs) @classmethod def from_service_account_file(cls, filename: str, *args, **kwargs): """Creates an instance of this client using the provided credentials file. Args: filename (str): The path to the service account private key json file. args: Additional arguments to pass to the constructor. kwargs: Additional arguments to pass to the constructor. Returns: UserEventServiceClient: The constructed client. """ credentials = service_account.Credentials.from_service_account_file( filename) kwargs["credentials"] = credentials return cls(*args, **kwargs) from_service_account_json = from_service_account_file @property def transport(self) -> UserEventServiceTransport: """Returns the transport used by the client instance. Returns: UserEventServiceTransport: The transport used by the client instance. """ return self._transport @staticmethod def event_store_path(project: str,location: str,catalog: str,event_store: str,) -> str: """Returns a fully-qualified event_store string.""" return "projects/{project}/locations/{location}/catalogs/{catalog}/eventStores/{event_store}".format(project=project, location=location, catalog=catalog, event_store=event_store, ) @staticmethod def parse_event_store_path(path: str) -> Dict[str,str]: """Parses a event_store path into its component segments.""" m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)/catalogs/(?P<catalog>.+?)/eventStores/(?P<event_store>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_billing_account_path(billing_account: str, ) -> str: """Returns a fully-qualified billing_account string.""" return "billingAccounts/{billing_account}".format(billing_account=billing_account, ) @staticmethod def parse_common_billing_account_path(path: str) -> Dict[str,str]: """Parse a billing_account path into its component segments.""" m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_folder_path(folder: str, ) -> str: """Returns a fully-qualified folder string.""" return "folders/{folder}".format(folder=folder, ) @staticmethod def parse_common_folder_path(path: str) -> Dict[str,str]: """Parse a folder path into its component segments.""" m = re.match(r"^folders/(?P<folder>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_organization_path(organization: str, ) -> str: """Returns a fully-qualified organization string.""" return "organizations/{organization}".format(organization=organization, ) @staticmethod def parse_common_organization_path(path: str) -> Dict[str,str]: """Parse a organization path into its component segments.""" m = re.match(r"^organizations/(?P<organization>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_project_path(project: str, ) -> str: """Returns a fully-qualified project string.""" return "projects/{project}".format(project=project, ) @staticmethod def parse_common_project_path(path: str) -> Dict[str,str]: """Parse a project path into its component segments.""" m = re.match(r"^projects/(?P<project>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_location_path(project: str, location: str, ) -> str: """Returns a fully-qualified location string.""" return "projects/{project}/locations/{location}".format(project=project, location=location, ) @staticmethod def parse_common_location_path(path: str) -> Dict[str,str]: """Parse a location path into its component segments.""" m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path) return m.groupdict() if m else {} def __init__(self, *, credentials: Optional[ga_credentials.Credentials] = None, transport: Union[str, UserEventServiceTransport, None] = None, client_options: Optional[client_options_lib.ClientOptions] = None, client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, ) -> None: """Instantiates the user event service client. Args: credentials (Optional[google.auth.credentials.Credentials]): The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. transport (Union[str, UserEventServiceTransport]): The transport to use. If set to None, a transport is chosen automatically. client_options (google.api_core.client_options.ClientOptions): Custom options for the client. It won't take effect if a ``transport`` instance is provided. (1) The ``api_endpoint`` property can be used to override the default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT environment variable can also be used to override the endpoint: "always" (always use the default mTLS endpoint), "never" (always use the default regular endpoint) and "auto" (auto switch to the default mTLS endpoint if client certificate is present, this is the default value). However, the ``api_endpoint`` property takes precedence if provided. (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable is "true", then the ``client_cert_source`` property can be used to provide client certificate for mutual TLS transport. If not provided, the default SSL client certificate will be used if present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not set, no client certificate will be used. client_info (google.api_core.gapic_v1.client_info.ClientInfo): The client info used to send a user-agent string along with API requests. If ``None``, then default info will be used. Generally, you only need to set this if you're developing your own client library. Raises: google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport creation failed for any reason. """ if isinstance(client_options, dict): client_options = client_options_lib.from_dict(client_options) if client_options is None: client_options = client_options_lib.ClientOptions() # Create SSL credentials for mutual TLS if needed. use_client_cert = bool(util.strtobool(os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false"))) client_cert_source_func = None is_mtls = False if use_client_cert: if client_options.client_cert_source: is_mtls = True client_cert_source_func = client_options.client_cert_source else: is_mtls = mtls.has_default_client_cert_source() if is_mtls: client_cert_source_func = mtls.default_client_cert_source() else: client_cert_source_func = None # Figure out which api endpoint to use. if client_options.api_endpoint is not None: api_endpoint = client_options.api_endpoint else: use_mtls_env = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto") if use_mtls_env == "never": api_endpoint = self.DEFAULT_ENDPOINT elif use_mtls_env == "always": api_endpoint = self.DEFAULT_MTLS_ENDPOINT elif use_mtls_env == "auto": if is_mtls: api_endpoint = self.DEFAULT_MTLS_ENDPOINT else: api_endpoint = self.DEFAULT_ENDPOINT else: raise MutualTLSChannelError( "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted " "values: never, auto, always" ) # Save or instantiate the transport. # Ordinarily, we provide the transport, but allowing a custom transport # instance provides an extensibility point for unusual situations. if isinstance(transport, UserEventServiceTransport): # transport is a UserEventServiceTransport instance. if credentials or client_options.credentials_file: raise ValueError("When providing a transport instance, " "provide its credentials directly.") if client_options.scopes: raise ValueError( "When providing a transport instance, provide its scopes " "directly." ) self._transport = transport else: Transport = type(self).get_transport_class(transport) self._transport = Transport( credentials=credentials, credentials_file=client_options.credentials_file, host=api_endpoint, scopes=client_options.scopes, client_cert_source_for_mtls=client_cert_source_func, quota_project_id=client_options.quota_project_id, client_info=client_info, always_use_jwt_access=True, ) def write_user_event(self, request: Union[user_event_service.WriteUserEventRequest, dict] = None, *, parent: str = None, user_event: gcr_user_event.UserEvent = None, retry: retries.Retry = gapic_v1.method.DEFAULT, timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> gcr_user_event.UserEvent: r"""Writes a single user event. Args: request (Union[google.cloud.recommendationengine_v1beta1.types.WriteUserEventRequest, dict]): The request object. Request message for WriteUserEvent method. parent (str): Required. The parent eventStore resource name, such as ``projects/1234/locations/global/catalogs/default_catalog/eventStores/default_event_store``. This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this should not be set. user_event (google.cloud.recommendationengine_v1beta1.types.UserEvent): Required. User event to write. This corresponds to the ``user_event`` field on the ``request`` instance; if ``request`` is provided, this should not be set. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. Returns: google.cloud.recommendationengine_v1beta1.types.UserEvent: UserEvent captures all metadata information recommendation engine needs to know about how end users interact with customers' website. """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. has_flattened_params = any([parent, user_event]) if request is not None and has_flattened_params: raise ValueError('If the `request` argument is set, then none of ' 'the individual field arguments should be set.') # Minor optimization to avoid making a copy if the user passes # in a user_event_service.WriteUserEventRequest. # There's no risk of modifying the input as we've already verified # there are no flattened fields. if not isinstance(request, user_event_service.WriteUserEventRequest): request = user_event_service.WriteUserEventRequest(request) # If we have keyword arguments corresponding to fields on the # request, apply these. if parent is not None: request.parent = parent if user_event is not None: request.user_event = user_event # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.write_user_event] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata) + ( gapic_v1.routing_header.to_grpc_metadata(( ("parent", request.parent), )), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, metadata=metadata, ) # Done; return the response. return response def collect_user_event(self, request: Union[user_event_service.CollectUserEventRequest, dict] = None, *, parent: str = None, user_event: str = None, uri: str = None, ets: int = None, retry: retries.Retry = gapic_v1.method.DEFAULT, timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> httpbody_pb2.HttpBody: r"""Writes a single user event from the browser. This uses a GET request to due to browser restriction of POST-ing to a 3rd party domain. This method is used only by the Recommendations AI JavaScript pixel. Users should not call this method directly. Args: request (Union[google.cloud.recommendationengine_v1beta1.types.CollectUserEventRequest, dict]): The request object. Request message for CollectUserEvent method. parent (str): Required. The parent eventStore name, such as ``projects/1234/locations/global/catalogs/default_catalog/eventStores/default_event_store``. This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this should not be set. user_event (str): Required. URL encoded UserEvent proto. This corresponds to the ``user_event`` field on the ``request`` instance; if ``request`` is provided, this should not be set. uri (str): Optional. The url including cgi- arameters but excluding the hash fragment. The URL must be truncated to 1.5K bytes to conservatively be under the 2K bytes. This is often more useful than the referer url, because many browsers only send the domain for 3rd party requests. This corresponds to the ``uri`` field on the ``request`` instance; if ``request`` is provided, this should not be set. ets (int): Optional. The event timestamp in milliseconds. This prevents browser caching of otherwise identical get requests. The name is abbreviated to reduce the payload bytes. This corresponds to the ``ets`` field on the ``request`` instance; if ``request`` is provided, this should not be set. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. Returns: google.api.httpbody_pb2.HttpBody: Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. has_flattened_params = any([parent, user_event, uri, ets]) if request is not None and has_flattened_params: raise ValueError('If the `request` argument is set, then none of ' 'the individual field arguments should be set.') # Minor optimization to avoid making a copy if the user passes # in a user_event_service.CollectUserEventRequest. # There's no risk of modifying the input as we've already verified # there are no flattened fields. if not isinstance(request, user_event_service.CollectUserEventRequest): request = user_event_service.CollectUserEventRequest(request) # If we have keyword arguments corresponding to fields on the # request, apply these. if parent is not None: request.parent = parent if user_event is not None: request.user_event = user_event if uri is not None: request.uri = uri if ets is not None: request.ets = ets # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.collect_user_event] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata) + ( gapic_v1.routing_header.to_grpc_metadata(( ("parent", request.parent), )), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, metadata=metadata, ) # Done; return the response. return response def list_user_events(self, request: Union[user_event_service.ListUserEventsRequest, dict] = None, *, parent: str = None, filter: str = None, retry: retries.Retry = gapic_v1.method.DEFAULT, timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListUserEventsPager: r"""Gets a list of user events within a time range, with potential filtering. Args: request (Union[google.cloud.recommendationengine_v1beta1.types.ListUserEventsRequest, dict]): The request object. Request message for ListUserEvents method. parent (str): Required. The parent eventStore resource name, such as ``projects/*/locations/*/catalogs/default_catalog/eventStores/default_event_store``. This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this should not be set. filter (str): Optional. Filtering expression to specify restrictions over returned events. This is a sequence of terms, where each term applies some kind of a restriction to the returned user events. Use this expression to restrict results to a specific time range, or filter events by eventType. eg: eventTime > "2012-04-23T18:25:43.511Z" eventsMissingCatalogItems eventTime<"2012-04-23T18:25:43.511Z" eventType=search We expect only 3 types of fields: :: * eventTime: this can be specified a maximum of 2 times, once with a less than operator and once with a greater than operator. The eventTime restrict should result in one contiguous valid eventTime range. * eventType: only 1 eventType restriction can be specified. * eventsMissingCatalogItems: specififying this will restrict results to events for which catalog items were not found in the catalog. The default behavior is to return only those events for which catalog items were found. Some examples of valid filters expressions: - Example 1: eventTime > "2012-04-23T18:25:43.511Z" eventTime < "2012-04-23T18:30:43.511Z" - Example 2: eventTime > "2012-04-23T18:25:43.511Z" eventType = detail-page-view - Example 3: eventsMissingCatalogItems eventType = search eventTime < "2018-04-23T18:30:43.511Z" - Example 4: eventTime > "2012-04-23T18:25:43.511Z" - Example 5: eventType = search - Example 6: eventsMissingCatalogItems This corresponds to the ``filter`` field on the ``request`` instance; if ``request`` is provided, this should not be set. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. Returns: google.cloud.recommendationengine_v1beta1.services.user_event_service.pagers.ListUserEventsPager: Response message for ListUserEvents method. Iterating over this object will yield results and resolve additional pages automatically. """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. has_flattened_params = any([parent, filter]) if request is not None and has_flattened_params: raise ValueError('If the `request` argument is set, then none of ' 'the individual field arguments should be set.') # Minor optimization to avoid making a copy if the user passes # in a user_event_service.ListUserEventsRequest. # There's no risk of modifying the input as we've already verified # there are no flattened fields. if not isinstance(request, user_event_service.ListUserEventsRequest): request = user_event_service.ListUserEventsRequest(request) # If we have keyword arguments corresponding to fields on the # request, apply these. if parent is not None: request.parent = parent if filter is not None: request.filter = filter # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.list_user_events] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata) + ( gapic_v1.routing_header.to_grpc_metadata(( ("parent", request.parent), )), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, metadata=metadata, ) # This method is paged; wrap the response in a pager, which provides # an `__iter__` convenience method. response = pagers.ListUserEventsPager( method=rpc, request=request, response=response, metadata=metadata, ) # Done; return the response. return response def purge_user_events(self, request: Union[user_event_service.PurgeUserEventsRequest, dict] = None, *, parent: str = None, filter: str = None, force: bool = None, retry: retries.Retry = gapic_v1.method.DEFAULT, timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> operation.Operation: r"""Deletes permanently all user events specified by the filter provided. Depending on the number of events specified by the filter, this operation could take hours or days to complete. To test a filter, use the list command first. Args: request (Union[google.cloud.recommendationengine_v1beta1.types.PurgeUserEventsRequest, dict]): The request object. Request message for PurgeUserEvents method. parent (str): Required. The resource name of the event_store under which the events are created. The format is ``projects/${projectId}/locations/global/catalogs/${catalogId}/eventStores/${eventStoreId}`` This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this should not be set. filter (str): Required. The filter string to specify the events to be deleted. Empty string filter is not allowed. This filter can also be used with ListUserEvents API to list events that will be deleted. The eligible fields for filtering are: - eventType - UserEvent.eventType field of type string. - eventTime - in ISO 8601 "zulu" format. - visitorId - field of type string. Specifying this will delete all events associated with a visitor. - userId - field of type string. Specifying this will delete all events associated with a user. Example 1: Deleting all events in a time range. ``eventTime > "2012-04-23T18:25:43.511Z" eventTime < "2012-04-23T18:30:43.511Z"`` Example 2: Deleting specific eventType in time range. ``eventTime > "2012-04-23T18:25:43.511Z" eventType = "detail-page-view"`` Example 3: Deleting all events for a specific visitor ``visitorId = visitor1024`` The filtering fields are assumed to have an implicit AND. This corresponds to the ``filter`` field on the ``request`` instance; if ``request`` is provided, this should not be set. force (bool): Optional. The default value is false. Override this flag to true to actually perform the purge. If the field is not set to true, a sampling of events to be deleted will be returned. This corresponds to the ``force`` field on the ``request`` instance; if ``request`` is provided, this should not be set. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. Returns: google.api_core.operation.Operation: An object representing a long-running operation. The result type for the operation will be :class:`google.cloud.recommendationengine_v1beta1.types.PurgeUserEventsResponse` Response of the PurgeUserEventsRequest. If the long running operation is successfully done, then this message is returned by the google.longrunning.Operations.response field. """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. has_flattened_params = any([parent, filter, force]) if request is not None and has_flattened_params: raise ValueError('If the `request` argument is set, then none of ' 'the individual field arguments should be set.') # Minor optimization to avoid making a copy if the user passes # in a user_event_service.PurgeUserEventsRequest. # There's no risk of modifying the input as we've already verified # there are no flattened fields. if not isinstance(request, user_event_service.PurgeUserEventsRequest): request = user_event_service.PurgeUserEventsRequest(request) # If we have keyword arguments corresponding to fields on the # request, apply these. if parent is not None: request.parent = parent if filter is not None: request.filter = filter if force is not None: request.force = force # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.purge_user_events] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata) + ( gapic_v1.routing_header.to_grpc_metadata(( ("parent", request.parent), )), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, metadata=metadata, ) # Wrap the response in an operation future. response = operation.from_gapic( response, self._transport.operations_client, user_event_service.PurgeUserEventsResponse, metadata_type=user_event_service.PurgeUserEventsMetadata, ) # Done; return the response. return response def import_user_events(self, request: Union[import_.ImportUserEventsRequest, dict] = None, *, parent: str = None, request_id: str = None, input_config: import_.InputConfig = None, errors_config: import_.ImportErrorsConfig = None, retry: retries.Retry = gapic_v1.method.DEFAULT, timeout: float = None, metadata: Sequence[Tuple[str, str]] = (), ) -> operation.Operation: r"""Bulk import of User events. Request processing might be synchronous. Events that already exist are skipped. Use this method for backfilling historical user events. Operation.response is of type ImportResponse. Note that it is possible for a subset of the items to be successfully inserted. Operation.metadata is of type ImportMetadata. Args: request (Union[google.cloud.recommendationengine_v1beta1.types.ImportUserEventsRequest, dict]): The request object. Request message for the ImportUserEvents request. parent (str): Required. ``projects/1234/locations/global/catalogs/default_catalog/eventStores/default_event_store`` This corresponds to the ``parent`` field on the ``request`` instance; if ``request`` is provided, this should not be set. request_id (str): Optional. Unique identifier provided by client, within the ancestor dataset scope. Ensures idempotency for expensive long running operations. Server-generated if unspecified. Up to 128 characters long. This is returned as google.longrunning.Operation.name in the response. Note that this field must not be set if the desired input config is catalog_inline_source. This corresponds to the ``request_id`` field on the ``request`` instance; if ``request`` is provided, this should not be set. input_config (google.cloud.recommendationengine_v1beta1.types.InputConfig): Required. The desired input location of the data. This corresponds to the ``input_config`` field on the ``request`` instance; if ``request`` is provided, this should not be set. errors_config (google.cloud.recommendationengine_v1beta1.types.ImportErrorsConfig): Optional. The desired location of errors incurred during the Import. This corresponds to the ``errors_config`` field on the ``request`` instance; if ``request`` is provided, this should not be set. retry (google.api_core.retry.Retry): Designation of what errors, if any, should be retried. timeout (float): The timeout for this request. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. Returns: google.api_core.operation.Operation: An object representing a long-running operation. The result type for the operation will be :class:`google.cloud.recommendationengine_v1beta1.types.ImportUserEventsResponse` Response of the ImportUserEventsRequest. If the long running operation was successful, then this message is returned by the google.longrunning.Operations.response field if the operation was successful. """ # Create or coerce a protobuf request object. # Sanity check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. has_flattened_params = any([parent, request_id, input_config, errors_config]) if request is not None and has_flattened_params: raise ValueError('If the `request` argument is set, then none of ' 'the individual field arguments should be set.') # Minor optimization to avoid making a copy if the user passes # in a import_.ImportUserEventsRequest. # There's no risk of modifying the input as we've already verified # there are no flattened fields. if not isinstance(request, import_.ImportUserEventsRequest): request = import_.ImportUserEventsRequest(request) # If we have keyword arguments corresponding to fields on the # request, apply these. if parent is not None: request.parent = parent if request_id is not None: request.request_id = request_id if input_config is not None: request.input_config = input_config if errors_config is not None: request.errors_config = errors_config # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.import_user_events] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata) + ( gapic_v1.routing_header.to_grpc_metadata(( ("parent", request.parent), )), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, metadata=metadata, ) # Wrap the response in an operation future. response = operation.from_gapic( response, self._transport.operations_client, import_.ImportUserEventsResponse, metadata_type=import_.ImportMetadata, ) # Done; return the response. return response def __enter__(self): return self def __exit__(self, type, value, traceback): """Releases underlying transport's resources. .. warning:: ONLY use as a context manager if the transport is NOT shared with other clients! Exiting the with block will CLOSE the transport and may cause errors in other clients! """ self.transport.close() try: DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( gapic_version=pkg_resources.get_distribution( "google-cloud-recommendations-ai", ).version, ) except pkg_resources.DistributionNotFound: DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo() __all__ = ( "UserEventServiceClient", )
44.469891
211
0.612524
[ "Apache-2.0" ]
googleapis/googleapis-gen
google/cloud/recommendationengine/v1beta1/recommendationengine-v1beta1-py/google/cloud/recommendationengine_v1beta1/services/user_event_service/client.py
45,048
Python
# -*- coding: utf-8 -*- import os import re from math import radians, degrees import numpy as np import pandas as pd import cv2 from pdftabextract import imgproc from pdftabextract.geom import pt from pdftabextract.common import read_xml, parse_pages, save_page_grids from pdftabextract.textboxes import rotate_textboxes, sorted_by_attr from pdftabextract.clustering import (find_clusters_1d_break_dist, calc_cluster_centers_1d, zip_clusters_and_values) from pdftabextract.splitpages import split_page_texts, create_split_pages_dict_structure from pdftabextract.extract import make_grid_from_positions, fit_texts_into_grid, datatable_to_dataframe #%% Some constants #DATAPATH = 'data/' #DATAPATH = 'ip/' #OUTPUTPATH = 'generated_output/' #OUTPUTPATH = 'op/' #INPUT_XML = 'output.xml' #INPUT_XML = 'output.xml' DATAPATH = 'data/' OUTPUTPATH = 'generated_output/' INPUT_XML = 'schoollist_1.pdf.xml' MIN_ROW_HEIGHT = 260 # minimum height of a row in pixels, measured in the scanned pages MIN_COL_WIDTH = 194 # very important. the minimum width of a column in pixels, measured in the scanned pages #%% Some helper functions def save_image_w_lines(iproc_obj, imgfilebasename, orig_img_as_background, file_suffix_prefix=''): file_suffix = 'lines-orig' if orig_img_as_background else 'lines' img_lines = iproc_obj.draw_lines(orig_img_as_background=orig_img_as_background) img_lines_file = os.path.join(OUTPUTPATH, '%s-%s.png' % (imgfilebasename, file_suffix_prefix + file_suffix)) print("> saving image with detected lines to '%s'" % img_lines_file) cv2.imwrite(img_lines_file, img_lines) #%% Read the XML # Load the XML that was generated with pdftohtml xmltree, xmlroot = read_xml(os.path.join(DATAPATH, INPUT_XML)) # parse it and generate a dict of pages pages = parse_pages(xmlroot, require_image=True) #%% Split the scanned double pages so that we can later process the lists page-by-page split_texts_and_images = [] # list of tuples with (double page, split text boxes, split images) for p_num, p in pages.items(): # get the image file of the scanned page imgfilebasename = p['image'][:p['image'].rindex('.')] imgfile = os.path.join(DATAPATH, p['image']) print("page %d: detecting lines in image file '%s'..." % (p_num, imgfile)) # create an image processing object with the scanned page iproc_obj = imgproc.ImageProc(imgfile) # calculate the scaling of the image file in relation to the text boxes coordinate system dimensions page_scaling_x = iproc_obj.img_w / p['width'] page_scaling_y = iproc_obj.img_h / p['height'] image_scaling = (page_scaling_x, # scaling in X-direction page_scaling_y) # scaling in Y-direction # detect the lines in the double pages lines_hough = iproc_obj.detect_lines(canny_low_thresh=50, canny_high_thresh=150, canny_kernel_size=3, hough_rho_res=1, hough_theta_res=np.pi/500, hough_votes_thresh=350) print("> found %d lines" % len(lines_hough)) save_image_w_lines(iproc_obj, imgfilebasename, True, 'bothpages-') # find the vertical line that separates both sides sep_line_img_x = iproc_obj.find_pages_separator_line(dist_thresh=MIN_COL_WIDTH/2) sep_line_page_x = sep_line_img_x / page_scaling_x print("> found pages separator line at %f (image space position) / %f (page space position)" % (sep_line_img_x, sep_line_page_x)) # split the scanned double page at the separator line split_images = iproc_obj.split_image(sep_line_img_x) # split the textboxes at the separator line split_texts = split_page_texts(p, sep_line_page_x) split_texts_and_images.append((p, split_texts, split_images)) # generate a new XML and "pages" dict structure from the split pages split_pages_xmlfile = os.path.join(OUTPUTPATH, INPUT_XML[:INPUT_XML.rindex('.')] + '.split.xml') print("> saving split pages XML to '%s'" % split_pages_xmlfile) split_tree, split_root, split_pages = create_split_pages_dict_structure(split_texts_and_images, save_to_output_path=split_pages_xmlfile) # we don't need the original double pages any more, we'll work with 'split_pages' del pages #%% Detect clusters of horizontal lines using the image processing module and rotate back or deskew pages hori_lines_clusters = {} pages_image_scaling = {} # scaling of the scanned page image in relation to the OCR page dimensions for each page for p_num, p in split_pages.items(): # get the image file of the scanned page imgfilebasename = p['image'][:p['image'].rindex('.')] imgfile = os.path.join(OUTPUTPATH, p['image']) print("page %d: detecting lines in image file '%s'..." % (p_num, imgfile)) # create an image processing object with the scanned page iproc_obj = imgproc.ImageProc(imgfile) # calculate the scaling of the image file in relation to the text boxes coordinate system dimensions page_scaling_x = iproc_obj.img_w / p['width'] page_scaling_y = iproc_obj.img_h / p['height'] pages_image_scaling[p_num] = (page_scaling_x, # scaling in X-direction page_scaling_y) # scaling in Y-direction # detect the lines lines_hough = iproc_obj.detect_lines(canny_low_thresh=50, canny_high_thresh=150, canny_kernel_size=3, hough_rho_res=1, hough_theta_res=np.pi/500, hough_votes_thresh=round(0.2 * iproc_obj.img_w)) print("> found %d lines" % len(lines_hough)) save_image_w_lines(iproc_obj, imgfilebasename, True) save_image_w_lines(iproc_obj, imgfilebasename, False) # find rotation or skew # the parameters are: # 1. the minimum threshold in radians for a rotation to be counted as such # 2. the maximum threshold for the difference between horizontal and vertical line rotation (to detect skew) # 3. an optional threshold to filter out "stray" lines whose angle is too far apart from the median angle of # all other lines that go in the same direction (no effect here) rot_or_skew_type, rot_or_skew_radians = iproc_obj.find_rotation_or_skew(radians(0.5), # uses "lines_hough" radians(1), omit_on_rot_thresh=radians(0.5)) # rotate back text boxes # since often no vertical lines can be detected and hence it cannot be determined if the page is rotated or skewed, # we assume that it's always rotated if rot_or_skew_type is not None: print("> rotating back by %f°" % -degrees(rot_or_skew_radians)) rotate_textboxes(p, -rot_or_skew_radians, pt(0, 0)) # rotate back detected lines lines_hough = iproc_obj.apply_found_rotation_or_skew(rot_or_skew_type, -rot_or_skew_radians) save_image_w_lines(iproc_obj, imgfilebasename + '-repaired', True) save_image_w_lines(iproc_obj, imgfilebasename + '-repaired', False) # cluster the detected *horizontal* lines using find_clusters_1d_break_dist as simple clustering function # (break on distance MIN_ROW_HEIGHT/2) # additionally, remove all cluster sections that are considered empty # a cluster is considered empty when the number of text boxes in it is below 10% of the median number of text boxes # per cluster section hori_clusters = iproc_obj.find_clusters(imgproc.DIRECTION_HORIZONTAL, find_clusters_1d_break_dist, remove_empty_cluster_sections_use_texts=p['texts'], # use this page's textboxes remove_empty_cluster_sections_n_texts_ratio=0.1, # 10% rule remove_empty_cluster_sections_scaling=page_scaling_y, # the positions are in "scanned image space" -> we scale them to "text box space" dist_thresh=MIN_ROW_HEIGHT/2) print("> found %d clusters" % len(hori_clusters)) if len(hori_clusters) > 0: # draw the clusters img_w_clusters = iproc_obj.draw_line_clusters(imgproc.DIRECTION_HORIZONTAL, hori_clusters) save_img_file = os.path.join(OUTPUTPATH, '%s-hori-clusters.png' % imgfilebasename) print("> saving image with detected horizontal clusters to '%s'" % save_img_file) cv2.imwrite(save_img_file, img_w_clusters) hori_lines_clusters[p_num] = hori_clusters else: print("> no horizontal line clusters found") # save split and repaired XML (i.e. XML with deskewed textbox positions) output_files_basename = INPUT_XML[:INPUT_XML.rindex('.')] repaired_xmlfile = os.path.join(OUTPUTPATH, output_files_basename + '.split.repaired.xml') print("saving split and repaired XML file to '%s'..." % repaired_xmlfile) split_tree.write(repaired_xmlfile) #%% Determine the rows and columns of the tables pttrn_schoolnum = re.compile(r'^\d{6}$') # a valid school number indicates a table row page_grids = {} print("detecting rows and columns...") for p_num, p in split_pages.items(): scaling_x, scaling_y = pages_image_scaling[p_num] # try to find out the table rows in this page using the horizontal lines that were detected before hori_lines = list(np.array(calc_cluster_centers_1d(hori_lines_clusters[p_num])) / scaling_y) hori_lines.append(p['height']) # last line: page bottom prev_line_y = 0 row_texts = [] row_positions = [] in_table = False # is True when the current segment is a real table row (not a table header or surrounding text) for line_y in hori_lines: # get all texts in this row segment_texts = [t for t in p['texts'] if prev_line_y < t['bottom'] <= line_y] if not segment_texts: continue # skip empty rows # try to find the start and the end of the table for t in segment_texts: t_val = t['value'].strip() if pttrn_schoolnum.search(t_val): # if this matches, we found the start of the table if not in_table: in_table = True row_positions.append(prev_line_y) break else: if in_table: # we found the end of the table in_table = False if in_table: # this is a table row, so add the texts and row positions to the respective lists row_texts.append(segment_texts) row_positions.append(line_y) prev_line_y = line_y # try to find out the table columns in this page using the distribution of x-coordinates of the left position of # each text box in all rows text_xs = [] for texts in row_texts: text_xs.extend([t['left'] for t in texts]) text_xs = np.array(text_xs) # make clusters of x positions text_xs_clusters = find_clusters_1d_break_dist(text_xs, dist_thresh=MIN_COL_WIDTH/2/scaling_x) text_xs_clusters_w_values = zip_clusters_and_values(text_xs_clusters, text_xs) col_positions = calc_cluster_centers_1d(text_xs_clusters_w_values) # remove falsely identified columns (i.e. merge columns with only a few text boxes) filtered_col_positions = [] n_rows = len(row_positions) n_cols = len(col_positions) if n_cols > 1 and n_rows > 1: top_y = row_positions[0] bottom_y = row_positions[-1] # append the rightmost text's right border as the last column border rightmost_pos = sorted_by_attr(p['texts'], 'right')[-1]['right'] col_positions.append(rightmost_pos) # merge columns with few text boxes texts_in_table = [t for t in p['texts'] if top_y < t['top'] + t['height']/2 <= bottom_y] prev_col_x = col_positions[0] for col_x in col_positions[1:]: col_texts = [t for t in texts_in_table if prev_col_x < t['left'] + t['width']/2 <= col_x] if len(col_texts) >= n_rows: # there should be at least one text box per row filtered_col_positions.append(prev_col_x) last_col_x = col_x prev_col_x = col_x # manually add border for the last column because it has very few or no text boxes filtered_col_positions.append(filtered_col_positions[-1] + (rightmost_pos - filtered_col_positions[-1]) / 2) filtered_col_positions.append(rightmost_pos) # create the grid if filtered_col_positions: grid = make_grid_from_positions(filtered_col_positions, row_positions) n_rows = len(grid) n_cols = len(grid[0]) print("> page %d: grid with %d rows, %d columns" % (p_num, n_rows, n_cols)) page_grids[p_num] = grid else: # this happens for the first page as there's no table on that print("> page %d: no table found" % p_num) # save the page grids # After you created the page grids, you should then check that they're correct using pdf2xml-viewer's # loadGridFile() function page_grids_file = os.path.join(OUTPUTPATH, output_files_basename + '.pagegrids.json') print("saving page grids JSON file to '%s'" % page_grids_file) save_page_grids(page_grids, page_grids_file) #%% Create data frames (requires pandas library) # For sake of simplicity, we will just fit the text boxes into the grid, merge the texts in their cells (splitting text # boxes to separate lines if necessary) and output the result. Normally, you would do some more parsing here, e.g. # extracting the address components from the second column. full_df = pd.DataFrame() print("fitting text boxes into page grids and generating final output...") for p_num, p in split_pages.items(): if p_num not in page_grids: continue # happens when no table was detected print("> page %d" % p_num) datatable, unmatched_texts = fit_texts_into_grid(p['texts'], page_grids[p_num], return_unmatched_texts=True) df = datatable_to_dataframe(datatable, split_texts_in_lines=True) df['from_page'] = p_num full_df = full_df.append(df, ignore_index=True) print("extracted %d rows from %d pages" % (len(full_df), len(split_pages))) csv_output_file = os.path.join(OUTPUTPATH, output_files_basename + '.csv') print("saving extracted data to '%s'" % csv_output_file) full_df.to_csv(csv_output_file, index=False) excel_output_file = os.path.join(OUTPUTPATH, output_files_basename + '.xlsx') print("saving extracted data to '%s'" % excel_output_file) full_df.to_excel(excel_output_file, index=False)
46.610592
180
0.679054
[ "Apache-2.0" ]
SagarRoy1996/TabularDataExtraction
examples/eg1/eg1.py
14,963
Python
# coding=utf-8 import sys import argparse import os from tensorflow.python.platform import gfile import numpy as np import tensorflow as tf from tensorflow.python.layers.core import Dense from utils.data_manager import load_data, load_data_one from collections import defaultdict from argparse import ArgumentParser from decode_helper import decode_one import sys reload(sys) sys.setdefaultencoding('utf8') os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' from tf_helper import train, evaluate, decode_data, decode_data_recover from model1 import construct_graph def init_args(): arg_parser = argparse.ArgumentParser() arg_parser.add_argument( '--data_path', default=os.path.dirname(os.path.abspath(__file__)) + '/data', type=str, help='Data path.') arg_parser.add_argument( '--load_data', default=False, type=bool, help='Load data.') arg_parser.add_argument( '--data', choices=['wikisql', 'spider', 'overnight', 'overnight_set'], default='wikisql', help='data to train & test') #arg_parser.add_argument('--tran_data', choices=['wikisql', 'spider', 'overnight'], default='overnight', help='data to transfer') arg_parser.add_argument( '--subset', choices=['all'], default='all', help='Subset of data.') arg_parser.add_argument( '--maxlen', default=60, type=int, help='Data record max length.') arg_parser.add_argument( '--annotation_path', default=os.path.dirname(os.path.abspath(__file__)) + '/data/DATA/wiki/', type=str, help='Data annotation path.') arg_parser.add_argument( '--mode', choices=['train', 'infer', 'transfer','txt'], default='infer', help='Run mode') #### Model configuration #### arg_parser.add_argument( '--cell', choices=['gru'], default='gru', help='Type of cell used, currently only standard GRU cell is supported' ) arg_parser.add_argument( '--output_vocab_size', default=20637, #default=20452, type=int, help='Output vocabulary size.') # Embedding sizes arg_parser.add_argument( '--embedding_dim', default=300, type=int, help='Size of word embeddings') #Hidden sizes arg_parser.add_argument( '--dim', default=400, type=int, help='Size of GRU hidden states') arg_parser.add_argument( '--hidden_size', default=256, type=int, help='Size of LSTM hidden states') arg_parser.add_argument( '--no_copy', default=False, action='store_true', help='Do not use copy mechanism') #### Training #### arg_parser.add_argument( '--vocab', type=str, help='Path of the serialized vocabulary') arg_parser.add_argument( '--glove_embed_path', default=None, type=str, help='Path to pretrained Glove mebedding') arg_parser.add_argument( '--batch_size', default=128, type=int, help='Batch size') arg_parser.add_argument( '--in_drop', default=0., type=float, help='In dropout rate') arg_parser.add_argument( '--out_drop', default=0., type=float, help='Out dropout rate') # training details arg_parser.add_argument( '--valid_epoch_interval', default=1, type=int, help='Perform validation every x epoch') arg_parser.add_argument( '--clip_grad', default=5., type=float, help='Clip gradients') arg_parser.add_argument( '--total_epochs', default=40, type=int, help='# of training epoches') arg_parser.add_argument( '--epochs', default=1, type=int, help='Record per x epoches') arg_parser.add_argument( '--lr', default=0.0001, type=float, help='Learning rate') arg_parser.add_argument( '--lr_decay', default=0.5, type=float, help='decay learning rate if the validation performance drops') #### decoding/validation/testing #### arg_parser.add_argument( '--load_model', default=False, type=bool, help='Whether to load model') arg_parser.add_argument( '--beam_width', default=5, type=int, help='Beam size for beam search') arg_parser.add_argument( '--decode_max_time_step', default=100, type=int, help='Maximum number of time steps used ' 'in decoding and sampling') args = arg_parser.parse_args() return args def model(args, train_env, infer_env): tf.reset_default_graph() train_graph = tf.Graph() infer_graph = tf.Graph() with train_graph.as_default(): train_env.x = tf.placeholder( tf.int32, shape=[None, args.maxlen], name='x') train_env.y = tf.placeholder(tf.int32, (None, args.maxlen), name='y') train_env.training = tf.placeholder_with_default( False, (), name='train_mode') train_env.train_op, train_env.loss, train_env.acc, sample_ids, logits = construct_graph( "train", train_env, args) train_env.saver = tf.train.Saver() #[print(n.name) for n in tf.get_default_graph().as_graph_def().node if 'xxxxx' in n.name] with infer_graph.as_default(): infer_env.x = tf.placeholder( tf.int32, shape=[None, args.maxlen], name='x') infer_env.y = tf.placeholder(tf.int32, (None, args.maxlen), name='y') infer_env.training = tf.placeholder_with_default( False, (), name='train_mode') _, infer_env.loss, infer_env.acc, infer_env.pred_ids, _ = construct_graph( "infer", infer_env, args) infer_env.infer_saver = tf.train.Saver() return train_graph, infer_graph def inferrence(args): args.load_model = True class Dummy: pass train_env = Dummy() infer_env = Dummy() _, infer_graph = model(args, train_env, infer_env) args.data = 'wikisql' args.load_data = True X_train, y_train = load_data(maxlen=args.maxlen,load=args.load_data, s='train') X_test, y_test = load_data(maxlen=args.maxlen,load=args.load_data, s='test') X_dev, y_dev = load_data(maxlen=args.maxlen,load=args.load_data, s='dev') #X_train, y_train, X_test, y_test, X_dev, y_dev = load_data(args) model2load = 'model/{}'.format(args.subset) sess = tf.InteractiveSession(graph=infer_graph) infer_env.infer_saver.restore(sess, model2load) print('===========dev set============') decode_data(sess, infer_env, X_dev, y_dev) em = decode_data_recover(sess, infer_env, X_dev, y_dev, 'dev') print('==========test set===========') decode_data(sess, infer_env, X_test, y_test) test_em = decode_data_recover(sess, infer_env, X_test, y_test, 'test') return def infer_one(args): args.load_model = True class Dummy: pass train_env = Dummy() infer_env = Dummy() _, infer_graph = model(args, train_env, infer_env) args.data = 'wikisql' args.load_data = True model2load = 'model/{}'.format(args.subset) sess = tf.InteractiveSession(graph=infer_graph) infer_env.infer_saver.restore(sess, model2load) print('===========decode============') X_one = load_data_one(args.maxlen, 'qs.txt') decode_one(sess, infer_env, X_one) return def train_model(args): class Dummy: pass train_env = Dummy() infer_env = Dummy() train_graph, infer_graph = model(args, train_env, infer_env) args.data = 'wikisql' args.load_data = True args.load_model = False X_train, y_train = load_data(maxlen=args.maxlen,load=args.load_data, s='train') X_test, y_test = load_data(maxlen=args.maxlen,load=args.load_data, s='test') X_dev, y_dev = load_data(maxlen=args.maxlen,load=args.load_data, s='dev') #X_train, y_train, X_test, y_test, X_dev, y_dev = load_data(args) model2load = 'model/{}'.format(args.subset) max_em, global_test_em, best_base = -1, -1, -1 acc = 0 sess1 = tf.InteractiveSession(graph=train_graph) sess1.run(tf.global_variables_initializer()) sess1.run(tf.local_variables_initializer()) sess2 = tf.InteractiveSession(graph=infer_graph) sess2.run(tf.global_variables_initializer()) sess2.run(tf.global_variables_initializer()) for base in range(args.total_epochs / args.epochs): print('\nIteration: %d (%d epochs)' % (base, args.epochs)) model2load = train( sess1, train_env, X_train, y_train, epochs=args.epochs, load=args.load_model, name=args.subset, batch_size=args.batch_size, base=base, model2Bload=model2load) args.load_model = True infer_env.infer_saver.restore(sess2, model2load) print('===========dev set============') dev_em = decode_data(sess2, infer_env, X_dev, y_dev) dev_em = decode_data_recover(sess2, infer_env, X_dev, y_dev, 'dev') print('==========test set===========') test_em = decode_data(sess2, infer_env, X_test, y_test) test_em = decode_data_recover(sess2, infer_env, X_test, y_test, 'test') if dev_em > max_em: max_em = dev_em global_test_em = test_em best_base = base print('\n Saving model for best testing') train_env.saver.save(sess1, 'best_model/{0}-{1}-{2:.2f}'.format(args.subset, base, max_em)) print('Max EM acc: %.4f during %d iteration.' % (max_em, best_base)) print('test EM acc: %.4f ' % global_test_em) return def transfer(args): load_model = args.load_model if args.mode == 'train' else True class Dummy: pass train_env = Dummy() infer_env = Dummy() _, infer_graph = model(args, train_env, infer_env) args.data = 'overnight' args.load_data = True #X_tran, y_tran = load_data(args) X_tran, y_tran = load_data(maxlen=args.maxlen,load=args.load_data, s='overnight') args.data = 'overnight_set' #tran_sets = load_data(args) tran_sets = load_data(maxlen=args.maxlen,load=args.load_data, s='overnight_set') model2load = 'model/{}'.format(args.subset) sess = tf.InteractiveSession(graph=infer_graph) infer_env.infer_saver.restore(sess, model2load) print('========subset transfer set========') subsets = ['basketball', 'calendar', 'housing', 'recipes', 'restaurants'] for subset, (X_tran_subset, y_tran_subset) in zip(subsets, tran_sets): print('---------' + subset + '---------') tran_em = decode_data( sess, infer_env, X_tran_subset, y_tran_subset, filename=str(subset + '.txt')) print('===========transfer set============') tran_em = decode_data(sess, infer_env, X_tran, y_tran) return if __name__ == '__main__': args = init_args() print(args) if args.mode == 'train': print('\nTrain model.') train_model(args) elif args.mode == 'infer': print('\nInference.') inferrence(args) elif args.mode == 'txt': print('\nInference from txt.') infer_one(args) elif args.mode == 'transfer': print('\nTransfer.') transfer(args)
33.683432
133
0.623188
[ "MIT" ]
VV123/NLIDB_gradient
main.py
11,385
Python
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations from django.utils import timezone class Migration(migrations.Migration): dependencies = [ ('nationalparks', '0009_auto_20150831_1721'), ] operations = [ migrations.AddField( model_name='federalsite', name='active_participant', field=models.BooleanField(default=True), ), migrations.AddField( model_name='federalsite', name='update_timestamp', field=models.DateTimeField(auto_now=True, default=timezone.now()), preserve_default=False, ), migrations.AddField( model_name='federalsite', name='version', field=models.PositiveIntegerField(default=0), preserve_default=False, ), ]
27.75
78
0.606982
[ "CC0-1.0" ]
18F/ekip-api
ekip/nationalparks/migrations/0010_auto_20150902_1902.py
888
Python
# 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. from fake_switches.command_processing.command_processor import CommandProcessor class BaseCommandProcessor(CommandProcessor): def __init__(self, switch_configuration, terminal_controller, logger, piping_processor): """ :type switch_configuration: fake_switches.switch_configuration.SwitchConfiguration :type terminal_controller: fake_switches.terminal.TerminalController :type logger: logging.Logger :type piping_processor: fake_switches.command_processing.piping_processor_base.PipingProcessorBase """ self.switch_configuration = switch_configuration self.terminal_controller = terminal_controller self.logger = logger self.piping_processor = piping_processor self.sub_processor = None self.continuing_to = None self.is_done = False self.replace_input = False self.awaiting_keystroke = False def process_command(self, line): if " | " in line: line, piping_command = line.split(" | ", 1) piping_started = self.activate_piping(piping_command) if not piping_started: return False processed = False if self.sub_processor: processed = self.delegate_to_sub_processor(line) if not processed: if self.continuing_to: processed = self.continue_command(line) else: processed = self.parse_and_execute_command(line) if not self.continuing_to and not self.awaiting_keystroke and not self.is_done and processed and not self.sub_processor: self.finish_piping() self.show_prompt() return processed def parse_and_execute_command(self, line): if line.strip(): func, args = self.get_command_func(line) if not func: self.logger.debug("%s can't process : %s, falling back to parent" % (self.__class__.__name__, line)) return False else: func(*args) return True def continue_command(self, line): func = self.continuing_to self.continue_to(None) func(line) return True def delegate_to_sub_processor(self, line): processed = self.sub_processor.process_command(line) if self.sub_processor.is_done: self.sub_processor = None self.show_prompt() return processed def move_to(self, new_process_class, *args): self.sub_processor = new_process_class(self.switch_configuration, self.terminal_controller, self.logger, self.piping_processor, *args) self.sub_processor.show_prompt() def continue_to(self, continuing_action): self.continuing_to = continuing_action def get_continue_command_func(self, cmd): return getattr(self, 'continue_' + cmd, None) def write(self, data): filtered = self.pipe(data) if filtered is not False: self.terminal_controller.write(filtered) def write_line(self, data): self.write(data + "\n") def show_prompt(self): if self.sub_processor is not None: self.sub_processor.show_prompt() else: self.write(self.get_prompt()) def get_prompt(self): pass def activate_piping(self, piping_command): return self.piping_processor.start_listening(piping_command) def pipe(self, data): if self.piping_processor.is_listening(): return self.piping_processor.pipe(data) else: return data def finish_piping(self): if self.piping_processor.is_listening(): self.piping_processor.stop_listening() def on_keystroke(self, callback, *args): def on_keystroke_handler(key): self.awaiting_keystroke = False self.terminal_controller.remove_any_key_handler() callback(*(args + (key,))) self.terminal_controller.add_any_key_handler(on_keystroke_handler) self.awaiting_keystroke = True
35.037594
142
0.666953
[ "Apache-2.0" ]
idjaw/fake-switches
fake_switches/command_processing/base_command_processor.py
4,660
Python
from __future__ import division import sys class Inf(float): __name__ = __name__ __file__ = __file__ @staticmethod def div(p, q): """ ``p / q`` returning the correct infinity instead of raising ZeroDivisionError. """ from math import copysign if q != 0.0: # Normal case, no infinities. return p / q elif p == 0.0: return p / q # Doesn't return, raises an Exception. elif copysign(1, q) > 0: # q is +0.0, return inf with same sign as p. return copysign(inf, p) else: # q is -0.0, return inf with flipped sign. return copysign(inf, -p) sys.modules[__name__] = inf = Inf("+inf")
22.939394
64
0.535007
[ "MIT" ]
sensiblecodeio/inf
inf.py
757
Python
import os import numpy as np from shapely.geometry import box, Polygon import geopandas as gpd from ..utils.core import _check_gdf_load, _check_crs from ..utils.tile import save_empty_geojson from ..utils.geo import gdf_get_projection_unit, split_multi_geometries from ..utils.geo import reproject_geometry from tqdm import tqdm class VectorTiler(object): """An object to tile geospatial vector data into smaller pieces. Arguments --------- Attributes ---------- """ def __init__(self, dest_dir=None, dest_crs=None, output_format='GeoJSON', verbose=False, super_verbose=False): if verbose or super_verbose: print('Preparing the tiler...') self.dest_dir = dest_dir if not os.path.isdir(self.dest_dir): os.makedirs(self.dest_dir) if dest_crs is not None: self.dest_crs = _check_crs(dest_crs) self.output_format = output_format self.verbose = verbose self.super_verbose = super_verbose self.tile_paths = [] # retains the paths of the last call to .tile() if self.verbose or self.super_verbose: print('Initialization done.') def tile(self, src, tile_bounds, tile_bounds_crs=None, geom_type='Polygon', split_multi_geoms=True, min_partial_perc=0.0, dest_fname_base='geoms', obj_id_col=None, output_ext='.geojson'): """Tile `src` into vector data tiles bounded by `tile_bounds`. Arguments --------- src : `str` or :class:`geopandas.GeoDataFrame` The source vector data to tile. Must either be a path to a GeoJSON or a :class:`geopandas.GeoDataFrame`. tile_bounds : list A :class:`list` made up of ``[left, top, right, bottom] `` sublists (this can be extracted from :class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery) tile_bounds_crs : int, optional The EPSG code or rasterio.crs.CRS object for the CRS that the tile bounds are in. RasterTiler.tile returns the CRS of the raster tiles and can be used here. If not provided, it's assumed that the CRS is the same as in `src`. This argument must be provided if the bound coordinates and `src` are not in the same CRS, otherwise tiling will not occur correctly. geom_type : str, optional (default: "Polygon") The type of geometries contained within `src`. Defaults to ``"Polygon"``, can also be ``"LineString"``. split_multi_geoms : bool, optional (default: True) Should multi-polygons or multi-linestrings generated by clipping a geometry into discontinuous pieces be separated? Defaults to yes (``True``). min_partial_perc : float, optional (default: 0.0) The minimum percentage of a :class:`shapely.geometry.Polygon` 's area or :class:`shapely.geometry.LineString` 's length that must be retained within a tile's bounds to be included in the output. Defaults to ``0.0``, meaning that the contained portion of a clipped geometry will be included, no matter how small. dest_fname_base : str, optional (default: 'geoms') The base filename to use when creating outputs. The lower left corner coordinates of the tile's bounding box will be appended when saving. obj_id_col : str, optional (default: None) If ``split_multi_geoms=True``, the name of a column that specifies a unique identifier for each geometry (e.g. the ``"BuildingId"`` column in many SpaceNet datasets.) See :func:`solaris.utils.geo.split_multi_geometries` for more. output_ext : str, optional, (default: geojson) Extension of output files, can be 'geojson' or 'json'. """ tile_gen = self.tile_generator(src, tile_bounds, tile_bounds_crs, geom_type, split_multi_geoms, min_partial_perc, obj_id_col=obj_id_col) self.tile_paths = [] for tile_gdf, tb in tqdm(tile_gen): if self.proj_unit not in ['meter', 'metre']: dest_path = os.path.join( self.dest_dir, '{}_{}_{}{}'.format(dest_fname_base, np.round(tb[0], 3), np.round(tb[3], 3), output_ext)) else: dest_path = os.path.join( self.dest_dir, '{}_{}_{}{}'.format(dest_fname_base, int(tb[0]), int(tb[3]), output_ext)) self.tile_paths.append(dest_path) if len(tile_gdf) > 0: tile_gdf.to_file(dest_path, driver='GeoJSON') else: save_empty_geojson(dest_path, self.dest_crs) def tile_generator(self, src, tile_bounds, tile_bounds_crs=None, geom_type='Polygon', split_multi_geoms=True, min_partial_perc=0.0, obj_id_col=None): """Generate `src` vector data tiles bounded by `tile_bounds`. Arguments --------- src : `str` or :class:`geopandas.GeoDataFrame` The source vector data to tile. Must either be a path to a GeoJSON or a :class:`geopandas.GeoDataFrame`. tile_bounds : list A :class:`list` made up of ``[left, top, right, bottom] `` sublists (this can be extracted from :class:`solaris.tile.raster_tile.RasterTiler` after tiling imagery) tile_bounds_crs : int, optional The EPSG code for the CRS that the tile bounds are in. If not provided, it's assumed that the CRS is the same as in `src`. This argument must be provided if the bound coordinates and `src` are not in the same CRS, otherwise tiling will not occur correctly. geom_type : str, optional (default: "Polygon") The type of geometries contained within `src`. Defaults to ``"Polygon"``, can also be ``"LineString"``. split_multi_geoms : bool, optional (default: True) Should multi-polygons or multi-linestrings generated by clipping a geometry into discontinuous pieces be separated? Defaults to yes (``True``). min_partial_perc : float, optional (default: 0.0) The minimum percentage of a :class:`shapely.geometry.Polygon` 's area or :class:`shapely.geometry.LineString` 's length that must be retained within a tile's bounds to be included in the output. Defaults to ``0.0``, meaning that the contained portion of a clipped geometry will be included, no matter how small. obj_id_col : str, optional (default: None) If ``split_multi_geoms=True``, the name of a column that specifies a unique identifier for each geometry (e.g. the ``"BuildingId"`` column in many SpaceNet datasets.) See :func:`solaris.utils.geo.split_multi_geometries` for more. Yields ------ tile_gdf : :class:`geopandas.GeoDataFrame` A tile geodataframe. tb : list A list with ``[left, top, right, bottom] `` coordinates for the boundaries contained by `tile_gdf`. """ self.src = _check_gdf_load(src) if self.verbose: print("Num tiles:", len(tile_bounds)) self.src_crs = _check_crs(self.src.crs) # check if the tile bounds and vector are in the same crs if tile_bounds_crs is not None: tile_bounds_crs = _check_crs(tile_bounds_crs) else: tile_bounds_crs = self.src_crs if self.src_crs != tile_bounds_crs: reproject_bounds = True # used to transform tb for clip_gdf() else: reproject_bounds = False self.proj_unit = self.src_crs.linear_units if getattr(self, 'dest_crs', None) is None: self.dest_crs = self.src_crs for i, tb in enumerate(tile_bounds): if self.super_verbose: print("\n", i, "/", len(tile_bounds)) if reproject_bounds: tile_gdf = clip_gdf(self.src, reproject_geometry(box(*tb), tile_bounds_crs, self.src_crs), min_partial_perc, geom_type, verbose=self.super_verbose) else: tile_gdf = clip_gdf(self.src, tb, min_partial_perc, geom_type, verbose=self.super_verbose) if self.src_crs != self.dest_crs: tile_gdf = tile_gdf.to_crs(crs=self.dest_crs.to_wkt()) if split_multi_geoms: split_multi_geometries(tile_gdf, obj_id_col=obj_id_col) yield tile_gdf, tb def search_gdf_polygon(gdf, tile_polygon): """Find polygons in a GeoDataFrame that overlap with `tile_polygon` . Arguments --------- gdf : :py:class:`geopandas.GeoDataFrame` A :py:class:`geopandas.GeoDataFrame` of polygons to search. tile_polygon : :py:class:`shapely.geometry.Polygon` A :py:class:`shapely.geometry.Polygon` denoting a tile's bounds. Returns ------- precise_matches : :py:class:`geopandas.GeoDataFrame` The subset of `gdf` that overlaps with `tile_polygon` . If there are no overlaps, this will return an empty :py:class:`geopandas.GeoDataFrame`. """ sindex = gdf.sindex possible_matches_index = list(sindex.intersection(tile_polygon.bounds)) possible_matches = gdf.iloc[possible_matches_index] precise_matches = possible_matches[ possible_matches.intersects(tile_polygon) ] if precise_matches.empty: precise_matches = gpd.GeoDataFrame(geometry=[]) return precise_matches def clip_gdf(gdf, tile_bounds, min_partial_perc=0.0, geom_type="Polygon", use_sindex=True, verbose=False): """Clip GDF to a provided polygon. Clips objects within `gdf` to the region defined by `poly_to_cut`. Also adds several columns to the output:: `origarea` The original area of the polygons (only used if `geom_type` == ``"Polygon"``). `origlen` The original length of the objects (only used if `geom_type` == ``"LineString"``). `partialDec` The fraction of the object that remains after clipping (fraction of area for Polygons, fraction of length for LineStrings.) Can filter based on this by using `min_partial_perc`. `truncated` Boolean indicator of whether or not an object was clipped. Arguments --------- gdf : :py:class:`geopandas.GeoDataFrame` A :py:class:`geopandas.GeoDataFrame` of polygons to clip. tile_bounds : `list` or :class:`shapely.geometry.Polygon` The geometry to clip objects in `gdf` to. This can either be a ``[left, top, right, bottom] `` bounds list or a :class:`shapely.geometry.Polygon` object defining the area to keep. min_partial_perc : float, optional The minimum fraction of an object in `gdf` that must be preserved. Defaults to 0.0 (include any object if any part remains following clipping). geom_type : str, optional Type of objects in `gdf`. Can be one of ``["Polygon", "LineString"]`` . Defaults to ``"Polygon"`` . use_sindex : bool, optional Use the `gdf` sindex be used for searching. Improves efficiency but requires `libspatialindex <http://libspatialindex.github.io/>`__ . verbose : bool, optional Switch to print relevant values. Returns ------- cut_gdf : :py:class:`geopandas.GeoDataFrame` `gdf` with all contained objects clipped to `poly_to_cut` . See notes above for details on additional clipping columns added. """ if isinstance(tile_bounds, tuple): tb = box(*tile_bounds) elif isinstance(tile_bounds, list): tb = box(*tile_bounds) elif isinstance(tile_bounds, Polygon): tb = tile_bounds if use_sindex and (geom_type == "Polygon"): gdf = search_gdf_polygon(gdf, tb) # if geom_type == "LineString": if 'origarea' in gdf.columns: pass else: if "geom_type" == "LineString": gdf['origarea'] = 0 else: gdf['origarea'] = gdf.area if 'origlen' in gdf.columns: pass else: if "geom_type" == "LineString": gdf['origlen'] = gdf.length else: gdf['origlen'] = 0 # TODO must implement different case for lines and for spatialIndex # (Assume RTree is already performed) cut_gdf = gdf.copy() cut_gdf.geometry = gdf.intersection(tb) if geom_type == 'Polygon': cut_gdf['partialDec'] = cut_gdf.area / cut_gdf['origarea'] cut_gdf = cut_gdf.loc[cut_gdf['partialDec'] > min_partial_perc, :] cut_gdf['truncated'] = (cut_gdf['partialDec'] != 1.0).astype(int) else: # assume linestrings # remove null cut_gdf = cut_gdf[cut_gdf['geometry'].notnull()] cut_gdf['partialDec'] = 1 cut_gdf['truncated'] = 0 # cut_gdf = cut_gdf[cut_gdf.geom_type != "GeometryCollection"] if len(cut_gdf) > 0 and verbose: print("clip_gdf() - gdf.iloc[0]:", gdf.iloc[0]) print("clip_gdf() - tb:", tb) print("clip_gdf() - gdf_cut:", cut_gdf) # TODO: IMPLEMENT TRUNCATION MEASUREMENT FOR LINESTRINGS return cut_gdf
44.080745
83
0.594688
[ "Apache-2.0" ]
CosmiQ/SpaceNet_SAR_Buildings_Solutions
3-SatShipAI/solaris/tile/vector_tile.py
14,194
Python
import os import argparse import gym from gym import envs import numpy as np from skimage import transform from stable_baselines.common.atari_wrappers import WarpFrame from stable_baselines.common.vec_env import VecVideoRecorder, VecFrameStack, VecNormalize from .utils import ALGOS, create_test_env, get_saved_hyperparams, get_latest_run_id, find_saved_model #----------------------------------------- import toy_simulator #import dVRL_simulator from skimage import transform from gym.spaces import Box import cv2 #----------------------------------------- if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--env', help='environment ID', type=str, default='CartPole-v1') parser.add_argument('-f', '--folder', help='Log folder', type=str, default='trained_agents') parser.add_argument('-o', '--output-folder', help='Output folder', type=str, default='logs/videos/') parser.add_argument('--algo', help='RL Algorithm', default='ppo2', type=str, required=False, choices=list(ALGOS.keys())) parser.add_argument('-n', '--n-timesteps', help='number of timesteps', default=1000, type=int) parser.add_argument('--n-envs', help='number of environments', default=1, type=int) parser.add_argument('--deterministic', action='store_true', default=False, help='Use deterministic actions') parser.add_argument('--seed', help='Random generator seed', type=int, default=0) parser.add_argument('--no-render', action='store_true', default=False, help='Do not render the environment (useful for tests)') parser.add_argument('--exp-id', help='Experiment ID (default: -1, no exp folder, 0: latest)', default=-1, type=int) args = parser.parse_args() env_id = args.env algo = args.algo folder = args.folder video_folder = args.output_folder seed = args.seed deterministic = args.deterministic video_length = args.n_timesteps n_envs = args.n_envs if args.exp_id == 0: args.exp_id = get_latest_run_id(os.path.join(folder, algo), env_id) print('Loading latest experiment, id={}'.format(args.exp_id)) # Sanity checks if args.exp_id > 0: log_path = os.path.join(folder, algo, '{}_{}'.format(env_id, args.exp_id)) else: log_path = os.path.join(folder, algo) model_path = find_saved_model(algo, log_path, env_id) stats_path = os.path.join(log_path, env_id) hyperparams, stats_path = get_saved_hyperparams(stats_path) is_atari = 'NoFrameskip' in env_id env = create_test_env(env_id, n_envs=n_envs, is_atari=is_atari, stats_path=stats_path, seed=seed, log_dir=None, should_render=not args.no_render, hyperparams=hyperparams) #env = RGBobs(env) model = ALGOS[algo].load(model_path) obs = env.reset() #obs = cv2.cvtColor(obs, cv2.COLOR_RGB2GRAY) #ADDED 2 #obs = cv2.resize(obs, (84,84), interpolation=cv2.INTER_AREA) #ADDED 2 #obs_dummy = env.reset() #ADDED 1 #obs = transform.resize(obs_dummy, (84,84)) #ADDED 1 #env.observation_space = Box(low=0, high=255, shape=obs.shape, dtype=np.uint8) #ADDED 1 #obs = obs[:,:, None]*255 #ADDED 1 # Note: apparently it renders by default env = VecVideoRecorder(env, video_folder, record_video_trigger=lambda x: x == 0, video_length=video_length, name_prefix="{}-{}".format(algo, env_id)) env.reset() for _ in range(video_length + 1): # action = [env.action_space.sample()] action, _ = model.predict(obs, deterministic=deterministic) if isinstance(env.action_space, gym.spaces.Box): action = np.clip(action, env.action_space.low, env.action_space.high) obs, _, _, _ = env.step(action) # Workaround for https://github.com/openai/gym/issues/893 if n_envs == 1 and 'Bullet' not in env_id and not is_atari: env = env.venv # DummyVecEnv while isinstance(env, VecNormalize) or isinstance(env, VecFrameStack): env = env.venv env.envs[0].env.close() else: # SubprocVecEnv env.close()
36.803419
109
0.640734
[ "MIT" ]
SilviaZirino/rl-baselines-zoo
utils/record_video.py
4,306
Python
from __future__ import absolute_import from __future__ import unicode_literals # # Copyright (c) 2014 Juniper Networks, Inc. All rights reserved. # from builtins import next from builtins import chr from builtins import str from builtins import range from builtins import object import copy import os import gevent from pprint import pformat import six from vnc_api import vnc_api from .exceptions import NoIdError, VncError from pysandesh.gen_py.sandesh.ttypes import SandeshLevel from cfgm_common import jsonutils as json from . import utils import datetime from operator import itemgetter from collections import OrderedDict from cfgm_common.datastore.drivers.cassandra_thrift import CassandraDriverThrift from cfgm_common.datastore.drivers.cassandra_cql import CassandraDriverCQL from cfgm_common.datastore import api as datastore_api JSON_NONE = json.dumps(None) class VncCassandraClient(object): @staticmethod def _is_metadata(column_name): return column_name[:5] == 'META:' @staticmethod def _is_parent(column_name): return column_name[:7] == 'parent:' @staticmethod def _is_prop(column_name): return column_name[:5] == 'prop:' @staticmethod def _is_prop_list(column_name): return column_name[:6] == 'propl:' @staticmethod def _is_prop_map(column_name): return column_name[:6] == 'propm:' @staticmethod def _is_ref(column_name): return column_name[:4] == 'ref:' @staticmethod def _is_backref(column_name): return column_name[:8] == 'backref:' @staticmethod def _is_children(column_name): return column_name[:9] == 'children:' def add(self, cf_name, key, value): try: self._cassandra_driver.insert(key, value, cf_name=cf_name) return True except Exception as e: self._logger("VNCCassandra, unable to add {}={}, error: {}".format( key, value, e), level=SandeshLevel.SYS_WARN) return False def delete(self, cf_name, key, columns=None): try: self._cassandra_driver.remove( key, columns, cf_name=cf_name) return True except Exception as e: self._logger("VNCCassandra, unable to del {}={}, error: {}".format( key, columns, e), level=SandeshLevel.SYS_WARN) return False def _get_resource_class(self, obj_type): if hasattr(self, '_db_client_mgr'): return self._db_client_mgr.get_resource_class(obj_type) cls_name = '%s' % (utils.CamelCase(obj_type)) return getattr(vnc_api, cls_name) # end _get_resource_class @classmethod def get_db_info(cls): db_info = [(datastore_api.UUID_KEYSPACE_NAME, [datastore_api.OBJ_UUID_CF_NAME, datastore_api.OBJ_FQ_NAME_CF_NAME, datastore_api.OBJ_SHARED_CF_NAME])] return db_info # end get_db_info def __init__(self, server_list, cassandra_driver, **options): if cassandra_driver == 'cql': driverClass = CassandraDriverCQL elif cassandra_driver == 'thrift': driverClass = CassandraDriverThrift # TODO(sahid): To satisfy test-framework which has its # specific py3 support for thrift we can have the above # condition, when that will be fixed we could uncomment # the code. #if six.PY3: # raise VncError( # "selected driver `{}` not supported for Python 3.".format( # cassandra_driver)) else: raise VncError( "datastore driver not selected, see `cassandra_driver`.") self._cassandra_driver = driverClass(server_list, **options) self._logger = self._cassandra_driver.options.logger self._logger('VNCCassandra started with driver {}'.format(driverClass), level=SandeshLevel.SYS_INFO) self._cache_uuid_to_fq_name = {} self._obj_cache_mgr = ObjectCacheManager( self._cassandra_driver.options.logger, self, max_entries=self._cassandra_driver.options.obj_cache_entries, obj_cache_exclude_types=self._cassandra_driver.options.obj_cache_exclude_types, debug_obj_cache_types=self._cassandra_driver.options.debug_obj_cache_types, ) self._obj_cache_exclude_types = self._cassandra_driver.options.obj_cache_exclude_types or [] # these functions make calls to pycassa xget() and get_range() # generator functions which can't be wrapped around handle_exceptions() # at the time of cassandra init, hence need to wrap these functions that # uses it to catch cassandra connection failures. self.object_update = self._cassandra_driver._handle_exceptions( self.object_update) self.object_list = self._cassandra_driver._handle_exceptions( self.object_list) self.object_read = self._cassandra_driver._handle_exceptions( self.object_read) self.object_raw_read = self._cassandra_driver._handle_exceptions( self.object_raw_read) self.object_delete = self._cassandra_driver._handle_exceptions( self.object_delete) self.prop_collection_read = self._cassandra_driver._handle_exceptions( self.prop_collection_read) self.uuid_to_fq_name = self._cassandra_driver._handle_exceptions( self.uuid_to_fq_name) self.uuid_to_obj_type = self._cassandra_driver._handle_exceptions( self.uuid_to_obj_type) self.fq_name_to_uuid = self._cassandra_driver._handle_exceptions( self.fq_name_to_uuid) self.get_shared = self._cassandra_driver._handle_exceptions( self.get_shared) self.walk = self._cassandra_driver._handle_exceptions(self.walk) if self._cassandra_driver.options.walk: self.walk() # end __init__ def _create_prop(self, bch, obj_uuid, prop_name, prop_val): self._cassandra_driver.insert( obj_uuid, {'prop:%s' % (prop_name): json.dumps(prop_val)}, batch=bch) # end _create_prop def _update_prop(self, bch, obj_uuid, prop_name, new_props): if new_props[prop_name] is None: self._cassandra_driver.remove(obj_uuid, columns=['prop:' + prop_name], batch=bch) else: self._cassandra_driver.insert( obj_uuid, {'prop:' + prop_name: json.dumps(new_props[prop_name])}, batch=bch) # prop has been accounted for, remove so only new ones remain del new_props[prop_name] # end _update_prop def _add_to_prop_list(self, bch, obj_uuid, prop_name, prop_elem_value, prop_elem_position): self._cassandra_driver.insert(obj_uuid, {'propl:%s:%s' % (prop_name, prop_elem_position): json.dumps(prop_elem_value)}, batch=bch) # end _add_to_prop_list def _delete_from_prop_list(self, bch, obj_uuid, prop_name, prop_elem_position): self._cassandra_driver.remove( obj_uuid, columns=['propl:%s:%s' % (prop_name, prop_elem_position)], batch=bch) # end _delete_from_prop_list def _set_in_prop_map(self, bch, obj_uuid, prop_name, prop_elem_value, prop_elem_position): self._cassandra_driver.insert(obj_uuid, {'propm:%s:%s' % (prop_name, prop_elem_position): json.dumps(prop_elem_value)}, batch=bch) # end _set_in_prop_map def _delete_from_prop_map(self, bch, obj_uuid, prop_name, prop_elem_position): self._cassandra_driver.remove( obj_uuid, columns=['propm:%s:%s' % (prop_name, prop_elem_position)], batch=bch) # end _delete_from_prop_map def _create_child(self, bch, parent_type, parent_uuid, child_type, child_uuid): child_col = {'children:%s:%s' % (child_type, child_uuid): JSON_NONE} self._cassandra_driver.insert(parent_uuid, child_col, batch=bch) parent_col = {'parent:%s:%s' % (parent_type, parent_uuid): JSON_NONE} self._cassandra_driver.insert(child_uuid, parent_col, batch=bch) # update latest_col_ts on parent object if parent_type not in self._obj_cache_exclude_types: self.update_latest_col_ts(bch, parent_uuid) # end _create_child def _delete_child(self, bch, parent_type, parent_uuid, child_type, child_uuid): self._cassandra_driver.remove( parent_uuid, columns=['children:%s:%s' % (child_type, child_uuid)], batch=bch) # update latest_col_ts on parent object if parent_type not in self._obj_cache_exclude_types: self.update_latest_col_ts(bch, parent_uuid) # end _delete_child def _create_ref(self, bch, obj_type, obj_uuid, ref_obj_type, ref_uuid, ref_data): j_ref_data = json.dumps(ref_data) symmetric_ref_updates = [] self._cassandra_driver.insert( obj_uuid, {'ref:%s:%s' % (ref_obj_type, ref_uuid): j_ref_data}, batch=bch) if obj_type == ref_obj_type: self._cassandra_driver.insert( ref_uuid, {'ref:%s:%s' % (obj_type, obj_uuid): j_ref_data}, batch=bch) self.update_last_modified(bch, obj_type, ref_uuid) symmetric_ref_updates = [ref_uuid] else: self._cassandra_driver.insert( ref_uuid, {'backref:%s:%s' % (obj_type, obj_uuid): j_ref_data}, batch=bch) # update latest_col_ts on referred object if ref_obj_type not in self._obj_cache_exclude_types: if ref_obj_type == obj_type: # evict other side of ref since it is stale from # GET /<old-ref-uuid> pov. self._obj_cache_mgr.evict(obj_type, [ref_uuid]) else: self.update_latest_col_ts(bch, ref_uuid) return symmetric_ref_updates # end _create_ref def _update_ref(self, bch, obj_type, obj_uuid, ref_obj_type, old_ref_uuid, new_ref_infos): if ref_obj_type not in new_ref_infos: # update body didn't touch this type, nop return [] symmetric_ref_updates = [] if old_ref_uuid not in new_ref_infos[ref_obj_type]: # remove old ref self._cassandra_driver.remove( obj_uuid, columns=['ref:%s:%s' % (ref_obj_type, old_ref_uuid)], batch=bch) if obj_type == ref_obj_type: self._cassandra_driver.remove( old_ref_uuid, columns=['ref:%s:%s' % (obj_type, obj_uuid)], batch=bch) try: self.update_last_modified(bch, obj_type, old_ref_uuid) symmetric_ref_updates = [old_ref_uuid] except NoIdError as e: # old_ref_uuid might have been deleted # if cache has the link, it will be evicted # if cache doesn't have, keyerror is caught and continued pass else: self._cassandra_driver.remove( old_ref_uuid, columns=['backref:%s:%s' % (obj_type, obj_uuid)], batch=bch) else: # retain old ref with new ref attr new_ref_data = new_ref_infos[ref_obj_type][old_ref_uuid] j_new_ref_data = json.dumps(new_ref_data) self._cassandra_driver.insert( obj_uuid, {'ref:%s:%s' % (ref_obj_type, old_ref_uuid): j_new_ref_data}, batch=bch) if obj_type == ref_obj_type: self._cassandra_driver.insert( old_ref_uuid, {'ref:%s:%s' % (obj_type, obj_uuid): j_new_ref_data}, batch=bch) self.update_last_modified(bch, obj_type, old_ref_uuid) symmetric_ref_updates = [old_ref_uuid] else: self._cassandra_driver.insert( old_ref_uuid, {'backref:%s:%s' % (obj_type, obj_uuid): j_new_ref_data}, batch=bch) # uuid has been accounted for, remove so only new ones remain del new_ref_infos[ref_obj_type][old_ref_uuid] # update latest_col_ts on referred object if ref_obj_type not in self._obj_cache_exclude_types: if ref_obj_type == obj_type: # evict other side of ref since it is stale from # GET /<old-ref-uuid> pov. self._obj_cache_mgr.evict(obj_type, [old_ref_uuid]) else: self.update_latest_col_ts(bch, old_ref_uuid) return symmetric_ref_updates # end _update_ref def _delete_ref(self, bch, obj_type, obj_uuid, ref_obj_type, ref_uuid): send = False symmetric_ref_updates = [] if bch is None: send = True bch = self._cassandra_driver.get_cf_batch(datastore_api.OBJ_UUID_CF_NAME) self._cassandra_driver.remove( obj_uuid, columns=['ref:%s:%s' % (ref_obj_type, ref_uuid)], batch=bch) if obj_type == ref_obj_type: self._cassandra_driver.remove(ref_uuid, columns=[ 'ref:%s:%s' % (obj_type, obj_uuid)], batch=bch) try: self.update_last_modified(bch, obj_type, ref_uuid) symmetric_ref_updates = [ref_uuid] except NoIdError as e: # ref_uuid might have been deleted # if cache has the link, it will be evicted # if cache doesn't have, keyerror is caught and continued pass else: self._cassandra_driver.remove( ref_uuid, columns=['backref:%s:%s' % (obj_type, obj_uuid)], batch=bch) # update latest_col_ts on referred object if ref_obj_type not in self._obj_cache_exclude_types: if ref_obj_type == obj_type: # evict other side of ref since it is stale from # GET /<old-ref-uuid> pov. self._obj_cache_mgr.evict(obj_type, [ref_uuid]) else: self.update_latest_col_ts(bch, ref_uuid) if send: bch.send() return symmetric_ref_updates # end _delete_ref def _get_xsd_class(self, xsd_type): return getattr(vnc_api, xsd_type) # end _get_xsd_class def object_create(self, obj_type, obj_id, obj_dict, uuid_batch=None, fqname_batch=None): obj_class = self._get_resource_class(obj_type) if uuid_batch: bch = uuid_batch else: # Gather column values for obj and updates to backrefs # in a batch and write it at the end bch = self._cassandra_driver.get_cf_batch(datastore_api.OBJ_UUID_CF_NAME) obj_cols = {} obj_cols['fq_name'] = json.dumps(obj_dict['fq_name']) obj_cols['type'] = json.dumps(obj_type) if obj_type not in self._obj_cache_exclude_types: obj_cols['META:latest_col_ts'] = JSON_NONE if 'parent_type' in obj_dict: # non config-root child parent_type = obj_dict['parent_type'] if parent_type not in obj_class.parent_types: msg = ("Invalid parent type: %s not in %s" % (parent_type, obj_class.parent_types)) return False, (400, msg) parent_object_type = self._get_resource_class( parent_type).object_type parent_fq_name = obj_dict['fq_name'][:-1] obj_cols['parent_type'] = json.dumps(parent_type) parent_uuid = self.fq_name_to_uuid(parent_object_type, parent_fq_name) self._create_child(bch, parent_object_type, parent_uuid, obj_type, obj_id) # Properties for prop_field in obj_class.prop_fields: field = obj_dict.get(prop_field) # Specifically checking for None if field is None: continue if prop_field == 'id_perms': field['created'] = datetime.datetime.utcnow().isoformat() field['last_modified'] = field['created'] if prop_field in obj_class.prop_list_fields: # store list elements in list order # iterate on wrapped element or directly or prop field if obj_class.prop_list_field_has_wrappers[prop_field]: wrapper_field_keys = list(field.keys()) if wrapper_field_keys: wrapper_field = wrapper_field_keys[0] list_coll = field[wrapper_field] else: list_coll = [] else: list_coll = field for i in range(len(list_coll)): self._add_to_prop_list( bch, obj_id, prop_field, list_coll[i], str(i)) elif prop_field in obj_class.prop_map_fields: # iterate on wrapped element or directly or prop field if obj_class.prop_map_field_has_wrappers[prop_field]: wrapper_field_keys = list(field.keys()) if wrapper_field_keys: wrapper_field = wrapper_field_keys[0] map_coll = field[wrapper_field] else: map_coll = [] else: map_coll = field map_key_name = obj_class.prop_map_field_key_names[prop_field] for map_elem in map_coll: map_key = map_elem[map_key_name] self._set_in_prop_map( bch, obj_id, prop_field, map_elem, map_key) else: self._create_prop(bch, obj_id, prop_field, field) # References # e.g. ref_field = 'network_ipam_refs' # ref_res_type = 'network-ipam' # ref_link_type = 'VnSubnetsType' # is_weakref = False symmetric_ref_updates = [] for ref_field in obj_class.ref_fields: ref_fld_types_list = list(obj_class.ref_field_types[ref_field]) ref_res_type = ref_fld_types_list[0] ref_link_type = ref_fld_types_list[1] ref_obj_type = self._get_resource_class(ref_res_type).object_type refs = obj_dict.get(ref_field, []) for ref in refs: ref_uuid = self.fq_name_to_uuid(ref_obj_type, ref['to']) ref_attr = ref.get('attr') ref_data = {'attr': ref_attr, 'is_weakref': False} ret = self._create_ref(bch, obj_type, obj_id, ref_obj_type, ref_uuid, ref_data) symmetric_ref_updates.extend(ret) self._cassandra_driver.insert(obj_id, obj_cols, batch=bch) if not uuid_batch: bch.send() # Update fqname table fq_name_str = ':'.join(obj_dict['fq_name']) fq_name_cols = {utils.encode_string(fq_name_str) + ':' + obj_id: JSON_NONE} if fqname_batch: fqname_batch.insert(obj_type, fq_name_cols) else: self._cassandra_driver.insert( cf_name=datastore_api.OBJ_FQ_NAME_CF_NAME, key=obj_type, columns=fq_name_cols) return (True, symmetric_ref_updates) # end object_create def object_raw_read(self, obj_type, obj_uuids, prop_names): obj_class = self._get_resource_class(obj_type) hit_obj_dicts, miss_uuids = self._obj_cache_mgr.read( obj_class, obj_uuids, prop_names, False) miss_obj_rows = self._cassandra_driver.multiget( datastore_api.OBJ_UUID_CF_NAME, miss_uuids, ['prop:' + x for x in prop_names]) miss_obj_dicts = [] for obj_uuid, columns in list(miss_obj_rows.items()): miss_obj_dict = {'uuid': obj_uuid} for prop_name in columns: # strip 'prop:' before sending result back miss_obj_dict[prop_name[5:]] = columns[prop_name] miss_obj_dicts.append(miss_obj_dict) return hit_obj_dicts + miss_obj_dicts def object_read(self, obj_type, obj_uuids, field_names=None, ret_readonly=False): if not obj_uuids: return (True, []) # if field_names=None, all fields will be read/returned req_fields = field_names obj_class = self._get_resource_class(obj_type) ref_fields = obj_class.ref_fields backref_fields = obj_class.backref_fields children_fields = obj_class.children_fields list_fields = obj_class.prop_list_fields map_fields = obj_class.prop_map_fields prop_fields = obj_class.prop_fields - (list_fields | map_fields) if ((ret_readonly is False) or (obj_type in self._obj_cache_exclude_types)): ignore_cache = True else: ignore_cache = False # optimize for common case of reading non-backref, non-children fields # ignoring columns starting from 'b' and 'c' - significant performance # impact in scaled setting. e.g. read of project # For caching (when ret values will be used for readonly # e.g. object read/list context): # 1. pick the hits, and for the misses.. # 2. read from db, cache, filter with fields # else read from db with specified field filters if (field_names is None or set(field_names) & (backref_fields | children_fields)): # atleast one backref/children field is needed include_backrefs_children = True if ignore_cache: hit_obj_dicts = [] miss_uuids = obj_uuids else: hit_obj_dicts, miss_uuids = self._obj_cache_mgr.read( obj_class, obj_uuids, field_names, include_backrefs_children, ) miss_obj_rows = self._cassandra_driver.multiget( datastore_api.OBJ_UUID_CF_NAME, miss_uuids, timestamp=True) else: # ignore reading backref + children columns include_backrefs_children = False if ignore_cache: hit_obj_dicts = [] miss_uuids = obj_uuids else: hit_obj_dicts, miss_uuids = self._obj_cache_mgr.read( obj_class, obj_uuids, field_names, include_backrefs_children, ) miss_obj_rows = self._cassandra_driver.multiget( datastore_api.OBJ_UUID_CF_NAME, miss_uuids, start='d', timestamp=True) if (ignore_cache or self._obj_cache_mgr.max_entries < len(miss_uuids)): # caller may modify returned value, or # cannot fit in cache, # just render with filter and don't cache rendered_objs = self._render_obj_from_db( obj_class, miss_obj_rows, req_fields, include_backrefs_children) obj_dicts = hit_obj_dicts + \ [v['obj_dict'] for k,v in list(rendered_objs.items())] else: # can fit and caller won't modify returned value, # so render without filter, cache and return # cached value rendered_objs_to_cache = self._render_obj_from_db( obj_class, miss_obj_rows, None, include_backrefs_children) field_filtered_objs = self._obj_cache_mgr.set( obj_type, rendered_objs_to_cache, req_fields, include_backrefs_children, ) obj_dicts = hit_obj_dicts + field_filtered_objs if not obj_dicts: if len(obj_uuids) == 1: raise NoIdError(obj_uuids[0]) else: return (True, []) return (True, obj_dicts) # end object_read def object_count_children(self, obj_type, obj_uuid, child_type): if child_type is None: return (False, '') obj_class = self._get_resource_class(obj_type) if child_type not in obj_class.children_fields: return (False, '%s is not a child type of %s' % (child_type, obj_type)) col_start = 'children:' + child_type[:-1] + ':' col_finish = 'children:' + child_type[:-1] + ';' num_children = self._cassandra_driver.get_count( datastore_api.OBJ_UUID_CF_NAME, obj_uuid, start=col_start, finish=col_finish) return (True, num_children) # end object_count_children def update_last_modified(self, bch, obj_type, obj_uuid, id_perms=None): if id_perms is None: id_perms = self._cassandra_driver.get_one_col( datastore_api.OBJ_UUID_CF_NAME, obj_uuid, 'prop:id_perms') id_perms['last_modified'] = datetime.datetime.utcnow().isoformat() self._update_prop(bch, obj_uuid, 'id_perms', {'id_perms': id_perms}) if obj_type not in self._obj_cache_exclude_types: self.update_latest_col_ts(bch, obj_uuid) # end update_last_modified def update_latest_col_ts(self, bch, obj_uuid): try: self._cassandra_driver.get_one_col(datastore_api.OBJ_UUID_CF_NAME, obj_uuid, 'type') except NoIdError: return self._cassandra_driver.insert(obj_uuid, {'META:latest_col_ts': JSON_NONE}, batch=bch) # end update_latest_col_ts def object_update(self, obj_type, obj_uuid, new_obj_dict, uuid_batch=None): obj_class = self._get_resource_class(obj_type) # Grab ref-uuids and properties in new version new_ref_infos = {} symmetric_ref_updates = [] # Properties new_props = {} for prop_field in obj_class.prop_fields: if prop_field in new_obj_dict: new_props[prop_field] = new_obj_dict[prop_field] # References # e.g. ref_field = 'network_ipam_refs' # ref_type = 'network-ipam' # ref_link_type = 'VnSubnetsType' # is_weakref = False for ref_field in obj_class.ref_fields: ref_fld_types_list = list(obj_class.ref_field_types[ref_field]) ref_res_type = ref_fld_types_list[0] ref_link_type = ref_fld_types_list[1] is_weakref = ref_fld_types_list[2] ref_obj_type = self._get_resource_class(ref_res_type).object_type if ref_field in new_obj_dict: new_refs = new_obj_dict[ref_field] new_ref_infos[ref_obj_type] = {} for new_ref in new_refs or []: try: new_ref_uuid = new_ref['uuid'] except KeyError: new_ref_uuid = self.fq_name_to_uuid(ref_obj_type, new_ref['to']) new_ref_attr = new_ref.get('attr') new_ref_data = {'attr': new_ref_attr, 'is_weakref': is_weakref} new_ref_infos[ref_obj_type][new_ref_uuid] = new_ref_data # Gather column values for obj and updates to backrefs # in a batch and write it at the end if uuid_batch: bch = uuid_batch else: bch = self._cassandra_driver.get_cf_batch( datastore_api.OBJ_UUID_CF_NAME) for col_name, col_value in self._cassandra_driver.xget( datastore_api.OBJ_UUID_CF_NAME, obj_uuid): if self._is_prop(col_name): (_, prop_name) = col_name.split(':') if prop_name == 'id_perms': # id-perms always has to be updated for last-mod timestamp # get it from request dict(or from db if not in request dict) new_id_perms = new_obj_dict.get( prop_name, json.loads(col_value)) self.update_last_modified( bch, obj_type, obj_uuid, new_id_perms) elif prop_name in new_obj_dict: self._update_prop( bch, obj_uuid, prop_name, new_props) if self._is_prop_list(col_name): (_, prop_name, prop_elem_position) = col_name.split(':', 2) if prop_name in new_props: # delete all old values of prop list self._delete_from_prop_list( bch, obj_uuid, prop_name, prop_elem_position) if self._is_prop_map(col_name): (_, prop_name, prop_elem_position) = col_name.split(':', 2) if prop_name in new_props: # delete all old values of prop list self._delete_from_prop_map( bch, obj_uuid, prop_name, prop_elem_position) if self._is_ref(col_name): (_, ref_type, ref_uuid) = col_name.split(':') ret = self._update_ref(bch, obj_type, obj_uuid, ref_type, ref_uuid, new_ref_infos) symmetric_ref_updates.extend(ret) # for all column names # create new refs for ref_type in list(new_ref_infos.keys()): for ref_uuid in list(new_ref_infos[ref_type].keys()): ref_data = new_ref_infos[ref_type][ref_uuid] ret = self._create_ref(bch, obj_type, obj_uuid, ref_type, ref_uuid, ref_data) symmetric_ref_updates.extend(ret) # create new props for prop_name in list(new_props.keys()): if prop_name in obj_class.prop_list_fields: # store list elements in list order # iterate on wrapped element or directly on prop field # for wrapped lists, store without the wrapper. regenerate # wrapper on read if (obj_class.prop_list_field_has_wrappers[prop_name] and new_props[prop_name]): wrapper_field = list(new_props[prop_name].keys())[0] list_coll = new_props[prop_name][wrapper_field] else: list_coll = new_props[prop_name] for i in range(len(list_coll)): self._add_to_prop_list(bch, obj_uuid, prop_name, list_coll[i], str(i)) elif prop_name in obj_class.prop_map_fields: # store map elements in key order # iterate on wrapped element or directly on prop field # for wrapped lists, store without the wrapper. regenerate # wrapper on read if (obj_class.prop_map_field_has_wrappers[prop_name] and new_props[prop_name]): wrapper_field = list(new_props[prop_name].keys())[0] map_coll = new_props[prop_name][wrapper_field] else: map_coll = new_props[prop_name] map_key_name = obj_class.prop_map_field_key_names[prop_name] for map_elem in map_coll: map_key = map_elem[map_key_name] self._set_in_prop_map(bch, obj_uuid, prop_name, map_elem, map_key) else: self._create_prop(bch, obj_uuid, prop_name, new_props[prop_name]) if not uuid_batch: try: bch.send() finally: self._obj_cache_mgr.evict(obj_type, [obj_uuid]) return (True, symmetric_ref_updates) # end object_update def object_list(self, obj_type, parent_uuids=None, back_ref_uuids=None, obj_uuids=None, count=False, filters=None, paginate_start=None, paginate_count=None): obj_class = self._get_resource_class(obj_type) children_fq_names_uuids = [] ret_marker = None anchored_op = True def filter_rows(coll_infos, filters=None): if not coll_infos or not filters: return coll_infos filtered_infos = {} columns = ['prop:%s' % filter_key for filter_key in filters if filter_key in obj_class.prop_fields] if not columns: return coll_infos rows = self._cassandra_driver.multiget(datastore_api.OBJ_UUID_CF_NAME, list(coll_infos.keys()), columns=columns) for obj_uuid, properties in list(rows.items()): # give chance for zk heartbeat/ping gevent.sleep(0) full_match = True for filter_key, filter_values in list(filters.items()): property = 'prop:%s' % filter_key if property not in properties: full_match = False break prop_value = properties[property] if isinstance(prop_value, dict): for filter_value in filter_values: try: filter_dict = json.loads(filter_value) except ValueError: continue if (six.viewitems(filter_dict) <= six.viewitems(prop_value)): break else: full_match = False break elif prop_value not in filter_values: full_match = False break if full_match: filtered_infos[obj_uuid] = coll_infos[obj_uuid] return filtered_infos # end filter_rows def get_fq_name_uuid_list(obj_uuids): ret_list = [] for obj_uuid in obj_uuids: try: if obj_type != self.uuid_to_obj_type(obj_uuid): continue obj_fq_name = self.uuid_to_fq_name(obj_uuid) ret_list.append((obj_fq_name, obj_uuid)) except NoIdError: pass return ret_list # end get_fq_name_uuid_list if parent_uuids: # go from parent to child ## tune start and count if paginated on same row #if paginate_start and (len(parent_uuids) == 1): if paginate_start and paginate_start != '0': start = 'children:%s:%s' % (obj_type, paginate_start[:-1]+chr(ord(paginate_start[-1])+1)) num_columns = paginate_count else: start = 'children:%s:' % (obj_type) num_columns = None obj_rows = self._cassandra_driver.multiget( datastore_api.OBJ_UUID_CF_NAME, parent_uuids, start=start, finish='children:%s;' % (obj_type), num_columns=num_columns, timestamp=True) def filter_rows_parent_anchor(sort=False): # flatten to [('children:<type>:<uuid>', (<val>,<ts>), *] all_cols = [cols for obj_key in list(obj_rows.keys()) for cols in list(obj_rows[obj_key].items())] all_child_infos = {} for col_name, col_val_ts in all_cols: # give chance for zk heartbeat/ping gevent.sleep(0) child_uuid = col_name.split(':')[2] if obj_uuids and child_uuid not in obj_uuids: continue if back_ref_uuids: child_cols = self._cassandra_driver.get( datastore_api.OBJ_UUID_CF_NAME, child_uuid, start='ref:', finish='ref;') child_ref_ids = {col.split(':')[2] for col in child_cols or []} if not set(back_ref_uuids) & child_ref_ids: continue all_child_infos[child_uuid] = {'uuid': child_uuid, 'tstamp': col_val_ts[1]} filt_child_infos = filter_rows(all_child_infos, filters) if not sort: ret_child_infos = list(filt_child_infos.values()) else: ret_child_infos = sorted(list(filt_child_infos.values()), key=itemgetter('tstamp')) return get_fq_name_uuid_list(r['uuid'] for r in ret_child_infos) # end filter_rows_parent_anchor children_fq_names_uuids.extend(filter_rows_parent_anchor(sort=True)) elif back_ref_uuids: # go from anchor to backrefs if paginate_start and paginate_start != '0': # get next lexical value of marker start = 'backref:%s:%s' % (obj_type, paginate_start[:-1]+chr(ord(paginate_start[-1])+1)) num_columns = paginate_count else: start = 'backref:%s:' % (obj_type) num_columns = None obj_rows = self._cassandra_driver.multiget( datastore_api.OBJ_UUID_CF_NAME, back_ref_uuids, start=start, finish='backref:%s;' % (obj_type), num_columns=num_columns, timestamp=True) def filter_rows_backref_anchor(): # flatten to [('backref:<obj-type>:<uuid>', (<val>,<ts>), *] all_cols = [cols for obj_key in list(obj_rows.keys()) for cols in list(obj_rows[obj_key].items())] all_backref_infos = {} for col_name, col_val_ts in all_cols: # give chance for zk heartbeat/ping gevent.sleep(0) backref_uuid = col_name.split(':')[2] if obj_uuids and backref_uuid not in obj_uuids: continue all_backref_infos[backref_uuid] = \ {'uuid': backref_uuid, 'tstamp': col_val_ts[1]} filt_backref_infos = filter_rows(all_backref_infos, filters) return get_fq_name_uuid_list(r['uuid'] for r in list(filt_backref_infos.values())) # end filter_rows_backref_anchor children_fq_names_uuids.extend(filter_rows_backref_anchor()) else: anchored_op = False if obj_uuids: # exact objects specified def filter_rows_object_list(): all_obj_infos = {} marker = None read_in = 0 start_idx = 0 if paginate_start and paginate_start != '0': # paginate through objects # in list order of obj_uuids try: start_idx = obj_uuids.index(paginate_start) + 1 except ValueError: # simulate end of pagination start_idx = len(obj_uuids) for obj_uuid in obj_uuids[start_idx:]: all_obj_infos[obj_uuid] = None read_in += 1 if paginate_start and read_in >= paginate_count: marker = obj_uuid break filt_obj_infos = filter_rows(all_obj_infos, filters) return get_fq_name_uuid_list(list(filt_obj_infos.keys())), marker # end filter_rows_object_list filtered_rows, ret_marker = filter_rows_object_list() children_fq_names_uuids.extend(filtered_rows) else: # grab all resources of this type if paginate_start and paginate_start != '0': start = paginate_start[:-1] + \ chr(ord(paginate_start[-1]) + 1) else: start = '' cols = self._cassandra_driver.xget( datastore_api.OBJ_FQ_NAME_CF_NAME, '%s' %(obj_type), start=start) def filter_rows_no_anchor(): marker = None all_obj_infos = {} read_in = 0 for col_name, _ in cols: # give chance for zk heartbeat/ping gevent.sleep(0) col_name_arr = utils.decode_string(col_name).split(':') obj_uuid = col_name_arr[-1] all_obj_infos[obj_uuid] = (col_name_arr[:-1], obj_uuid) read_in += 1 if paginate_start and read_in >= paginate_count: marker = col_name break filt_obj_infos = filter_rows(all_obj_infos, filters) return list(filt_obj_infos.values()), marker # end filter_rows_no_anchor if count and not filters: # when listing all objects of a type # return early if only count query is in request return (True, sum(1 for col in cols), None) filtered_rows, ret_marker = filter_rows_no_anchor() children_fq_names_uuids.extend(filtered_rows) if count: return (True, len(children_fq_names_uuids), None) # for anchored list with pagination, # prune from union of anchors and last uuid is marker if paginate_start and anchored_op: children_fq_names_uuids = sorted(children_fq_names_uuids, key=lambda fqn_uuid: fqn_uuid[1]) if len(children_fq_names_uuids) > paginate_count: children_fq_names_uuids = children_fq_names_uuids[:paginate_count] if not children_fq_names_uuids: ret_marker = None else: ret_marker = children_fq_names_uuids[-1][1] return (True, children_fq_names_uuids, ret_marker) # end object_list def object_delete(self, obj_type, obj_uuid): obj_class = self._get_resource_class(obj_type) fq_name = self._cassandra_driver.get_one_col(datastore_api.OBJ_UUID_CF_NAME, obj_uuid, 'fq_name') bch = self._cassandra_driver.get_cf_batch(datastore_api.OBJ_UUID_CF_NAME) # unlink from parent col_start = 'parent:' col_fin = 'parent;' col_name_iter = self._cassandra_driver.xget(datastore_api.OBJ_UUID_CF_NAME, obj_uuid, start=col_start, finish=col_fin) for (col_name, col_val) in col_name_iter: (_, parent_type, parent_uuid) = col_name.split(':') self._delete_child( bch, parent_type, parent_uuid, obj_type, obj_uuid) # remove refs col_start = 'ref:' col_fin = 'ref;' col_name_iter = self._cassandra_driver.xget(datastore_api.OBJ_UUID_CF_NAME, obj_uuid, start=col_start, finish=col_fin) symmetric_ref_updates = [] for (col_name, col_val) in col_name_iter: (_, ref_type, ref_uuid) = col_name.split(':') ret = self._delete_ref(bch, obj_type, obj_uuid, ref_type, ref_uuid) symmetric_ref_updates.extend(ret) # remove link from relaxed back refs col_start = 'relaxbackref:' col_fin = 'relaxbackref;' col_name_iter = self._cassandra_driver.xget(datastore_api.OBJ_UUID_CF_NAME, obj_uuid, start=col_start, finish=col_fin) for (col_name, col_val) in col_name_iter: (_, backref_uuid) = col_name.split(':') self._delete_ref(bch, None, backref_uuid, obj_type, obj_uuid) self._cassandra_driver.remove(obj_uuid, batch=bch) try: bch.send() finally: self._obj_cache_mgr.evict(obj_type, [obj_uuid]) # Update fqname table fq_name_str = ':'.join(fq_name) fq_name_col = utils.encode_string(fq_name_str) + ':' + obj_uuid self._cassandra_driver.remove( cf_name=datastore_api.OBJ_FQ_NAME_CF_NAME, key=obj_type, columns=[fq_name_col]) # Purge map naming cache self.cache_uuid_to_fq_name_del(obj_uuid) return (True, symmetric_ref_updates) # end object_delete def prop_collection_read(self, obj_type, obj_uuid, obj_fields, position): obj_class = self._get_resource_class(obj_type) result = {} # always read-in id-perms for upper-layers to do rbac/visibility result['id_perms'] = self._cassandra_driver.get_one_col( datastore_api.OBJ_UUID_CF_NAME, obj_uuid, 'prop:id_perms') # read in prop-list or prop-map fields for field in obj_fields: if field in obj_class.prop_list_fields: prop_pfx = 'propl' elif field in obj_class.prop_map_fields: prop_pfx = 'propm' else: continue if position: col_start = '%s:%s:%s' % (prop_pfx, field, position) col_end = '%s:%s:%s' % (prop_pfx, field, position) else: col_start = '%s:%s:' % (prop_pfx, field) col_end = '%s:%s;' % (prop_pfx, field) obj_cols = self._cassandra_driver.xget( datastore_api.OBJ_UUID_CF_NAME, obj_uuid, start=col_start, finish=col_end) result[field] = [] for name, value in obj_cols: # tuple of col_value, position. result is already sorted # lexically by position (necessary only for list property) result[field].append((json.loads(value), name.split(':', 2)[-1])) return (True, result) # end prop_collection_read def cache_uuid_to_fq_name_add(self, id, fq_name, obj_type): self._cache_uuid_to_fq_name[id] = (fq_name, obj_type) # end cache_uuid_to_fq_name_add def cache_uuid_to_fq_name_del(self, id): self._cache_uuid_to_fq_name.pop(id, None) # end cache_uuid_to_fq_name_del def uuid_to_fq_name(self, id): try: return copy.copy(self._cache_uuid_to_fq_name[id][0]) except KeyError: obj = self._cassandra_driver.get(datastore_api.OBJ_UUID_CF_NAME, id, columns=['fq_name', 'type']) if not obj: raise NoIdError(id) if 'type' not in obj or 'fq_name' not in obj: raise NoIdError(id) fq_name = obj['fq_name'] obj_type = obj['type'] self.cache_uuid_to_fq_name_add(id, fq_name, obj_type) return copy.copy(fq_name) # end uuid_to_fq_name def uuid_to_obj_type(self, id): try: return self._cache_uuid_to_fq_name[id][1] except KeyError: obj = self._cassandra_driver.get(datastore_api.OBJ_UUID_CF_NAME, id, columns=['fq_name', 'type']) if not obj: raise NoIdError(id) if 'type' not in obj or 'fq_name' not in obj: raise NoIdError(id) fq_name = obj['fq_name'] obj_type = obj['type'] self.cache_uuid_to_fq_name_add(id, fq_name, obj_type) return obj_type # end uuid_to_obj_type def fq_name_to_uuid(self, obj_type, fq_name): fq_name_str = utils.encode_string(':'.join(fq_name)) col_infos = self._cassandra_driver.get(datastore_api.OBJ_FQ_NAME_CF_NAME, obj_type, start=fq_name_str + ':', finish=fq_name_str + ';') if not col_infos: raise NoIdError('%s %s' % (obj_type, fq_name_str)) if len(col_infos) > 1: raise VncError('Multi match %s for %s' % (fq_name_str, obj_type)) fq_name_uuid = utils.decode_string(col_infos.popitem()[0]).split(':') if obj_type != 'route_target' and fq_name_uuid[:-1] != fq_name: raise NoIdError('%s %s' % (obj_type, fq_name_str)) return fq_name_uuid[-1] # end fq_name_to_uuid # return all objects shared with a (share_type, share_id) def get_shared(self, obj_type, share_id='', share_type='global'): result = [] column = '%s:%s' % (share_type, share_id) col_infos = self._cassandra_driver.get(datastore_api.OBJ_SHARED_CF_NAME, obj_type, start=column + ':', finish=column + ';') if not col_infos: return None for (col_name, col_val) in list(col_infos.items()): # ('*:*:f7963198-08a4-4b96-a02e-41cc66593163', u'7') obj_uuid = col_name.split(':')[-1] result.append((obj_uuid, col_val)) return result # share an object 'obj_id' with <share_type:share_id> # rwx indicate type of access (sharing) allowed def set_shared(self, obj_type, obj_id, share_id = '', share_type = 'global', rwx = 7): col_name = '%s:%s:%s' % (share_type, share_id, obj_id) self._cassandra_driver.insert( cf_name=datastore_api.OBJ_SHARED_CF_NAME, key=obj_type, columns={col_name:json.dumps(rwx)}) # delete share of 'obj_id' object with <share_type:share_id> def del_shared(self, obj_type, obj_id, share_id = '', share_type = 'global'): col_name = '%s:%s:%s' % (share_type, share_id, obj_id) self._cassandra_driver.remove( cf_name=datastore_api.OBJ_SHARED_CF_NAME, key=obj_type, columns=[col_name]) def _render_obj_from_db(self, obj_class, obj_rows, field_names=None, include_backrefs_children=False): ref_fields = obj_class.ref_fields backref_fields = obj_class.backref_fields children_fields = obj_class.children_fields list_fields = obj_class.prop_list_fields map_fields = obj_class.prop_map_fields prop_fields = obj_class.prop_fields - (list_fields | map_fields) results = {} for obj_uuid, obj_cols in list(obj_rows.items()): if 'type' not in obj_cols or 'fq_name' not in obj_cols: # if object has been deleted, these fields may not # be present continue if obj_class.object_type != obj_cols.pop('type')[0]: continue id_perms_ts = 0 row_latest_ts = 0 result = {} result['uuid'] = obj_uuid result['fq_name'] = obj_cols.pop('fq_name')[0] for col_name in list(obj_cols.keys()): if self._is_parent(col_name): # non config-root child (_, _, parent_uuid) = col_name.split(':') try: result['parent_type'] = obj_cols['parent_type'][0] except KeyError: # parent_type may not be present in obj_cols pass result['parent_uuid'] = parent_uuid continue if self._is_prop(col_name): (_, prop_name) = col_name.split(':') if prop_name == 'id_perms': id_perms_ts = obj_cols[col_name][1] if ((prop_name not in prop_fields) or (field_names and prop_name not in field_names)): continue result[prop_name] = obj_cols[col_name][0] continue if self._is_prop_list(col_name): (_, prop_name, prop_elem_position) = col_name.split(':') if field_names and prop_name not in field_names: continue if obj_class.prop_list_field_has_wrappers[prop_name]: prop_field_types = obj_class.prop_field_types[prop_name] wrapper_type = prop_field_types['xsd_type'] wrapper_cls = self._get_xsd_class(wrapper_type) wrapper_field = wrapper_cls.attr_fields[0] if prop_name not in result: result[prop_name] = {wrapper_field: []} result[prop_name][wrapper_field].append( (obj_cols[col_name][0], prop_elem_position)) else: if prop_name not in result: result[prop_name] = [] result[prop_name].append((obj_cols[col_name][0], prop_elem_position)) continue if self._is_prop_map(col_name): (_, prop_name, _) = col_name.split(':', 2) if field_names and prop_name not in field_names: continue if obj_class.prop_map_field_has_wrappers[prop_name]: prop_field_types = obj_class.prop_field_types[prop_name] wrapper_type = prop_field_types['xsd_type'] wrapper_cls = self._get_xsd_class(wrapper_type) wrapper_field = wrapper_cls.attr_fields[0] if prop_name not in result: result[prop_name] = {wrapper_field: []} result[prop_name][wrapper_field].append( obj_cols[col_name][0]) else: if prop_name not in result: result[prop_name] = [] result[prop_name].append(obj_cols[col_name][0]) continue if self._is_children(col_name): (_, child_type, child_uuid) = col_name.split(':') if field_names and '%ss' %(child_type) not in field_names: continue if child_type+'s' not in children_fields: continue child_tstamp = obj_cols[col_name][1] try: self._read_child(result, obj_uuid, child_type, child_uuid, child_tstamp) except NoIdError: continue continue if self._is_ref(col_name): (_, ref_type, ref_uuid) = col_name.split(':') if ((ref_type+'_refs' not in ref_fields) or (field_names and ref_type + '_refs' not in field_names)): continue self._read_ref(result, obj_uuid, ref_type, ref_uuid, obj_cols[col_name][0]) continue if self._is_backref(col_name): (_, back_ref_type, back_ref_uuid) = col_name.split(':') if back_ref_type+'_back_refs' not in backref_fields: continue if (field_names and '%s_back_refs' %(back_ref_type) not in field_names): continue try: self._read_back_ref(result, obj_uuid, back_ref_type, back_ref_uuid, obj_cols[col_name][0]) except NoIdError: continue continue if self._is_metadata(col_name): (_, meta_type) = col_name.split(':') if meta_type == 'latest_col_ts': row_latest_ts = obj_cols[col_name][1] continue # for all column names # sort children by creation time for child_field in obj_class.children_fields: if child_field not in result: continue sorted_children = sorted(result[child_field], key = itemgetter('tstamp')) # re-write result's children without timestamp result[child_field] = sorted_children [child.pop('tstamp') for child in result[child_field]] # for all children # Ordering property lists by position attribute for prop_name in (obj_class.prop_list_fields & set(result.keys())): if isinstance(result[prop_name], list): result[prop_name] = [el[0] for el in sorted(result[prop_name], key=itemgetter(1))] elif isinstance(result[prop_name], dict): wrapper, unsorted_list = result[prop_name].popitem() result[prop_name][wrapper] = [el[0] for el in sorted(unsorted_list, key=itemgetter(1))] # 'id_perms_ts' tracks timestamp of id-perms column # i.e. latest update of *any* prop or ref. # 'row_latest_ts' tracks timestamp of last modified column # so any backref/children column is also captured. 0=>unknown results[obj_uuid] = {'obj_dict': result, 'id_perms_ts': id_perms_ts} if include_backrefs_children: # update our copy of ts only if we read the # corresponding fields from db results[obj_uuid]['row_latest_ts'] = row_latest_ts # end for all rows return results # end _render_obj_from_db def _read_child(self, result, obj_uuid, child_obj_type, child_uuid, child_tstamp): if '%ss' % (child_obj_type) not in result: result['%ss' % (child_obj_type)] = [] child_res_type = self._get_resource_class(child_obj_type).resource_type child_info = {} child_info['to'] = self.uuid_to_fq_name(child_uuid) child_info['uuid'] = child_uuid child_info['tstamp'] = child_tstamp result['%ss' % (child_obj_type)].append(child_info) # end _read_child def _read_ref(self, result, obj_uuid, ref_obj_type, ref_uuid, ref_data_json): if '%s_refs' % (ref_obj_type) not in result: result['%s_refs' % (ref_obj_type)] = [] ref_data = ref_data_json ref_info = {} try: ref_info['to'] = self.uuid_to_fq_name(ref_uuid) except NoIdError: ref_info['to'] = ['ERROR'] if ref_data: try: ref_info['attr'] = ref_data['attr'] except KeyError: # TODO remove backward compat old format had attr directly ref_info['attr'] = ref_data ref_info['uuid'] = ref_uuid result['%s_refs' % (ref_obj_type)].append(ref_info) # end _read_ref def _read_back_ref(self, result, obj_uuid, back_ref_obj_type, back_ref_uuid, back_ref_data_json): if '%s_back_refs' % (back_ref_obj_type) not in result: result['%s_back_refs' % (back_ref_obj_type)] = [] back_ref_info = {} back_ref_info['to'] = self.uuid_to_fq_name(back_ref_uuid) back_ref_data = back_ref_data_json if back_ref_data: try: back_ref_info['attr'] = back_ref_data['attr'] except KeyError: # TODO remove backward compat old format had attr directly back_ref_info['attr'] = back_ref_data back_ref_info['uuid'] = back_ref_uuid result['%s_back_refs' % (back_ref_obj_type)].append(back_ref_info) # end _read_back_ref def walk(self, fn=None): type_to_object = {} for obj_uuid, obj_col in self._cassandra_driver.get_range( datastore_api.OBJ_UUID_CF_NAME, columns=['type', 'fq_name']): try: obj_type = json.loads(obj_col['type']) obj_fq_name = json.loads(obj_col['fq_name']) # prep cache to avoid n/w round-trip in db.read for ref self.cache_uuid_to_fq_name_add(obj_uuid, obj_fq_name, obj_type) try: type_to_object[obj_type].append(obj_uuid) except KeyError: type_to_object[obj_type] = [obj_uuid] except Exception as e: self._logger('Error in db walk read %s' % (str(e)), level=SandeshLevel.SYS_ERR) continue if fn is None: return [] walk_results = [] for obj_type, uuid_list in list(type_to_object.items()): try: self._logger('DB walk: obj_type %s len %s' % (obj_type, len(uuid_list)), level=SandeshLevel.SYS_INFO) result = fn(obj_type, uuid_list) if result: walk_results.append(result) except Exception as e: self._logger('Error in db walk invoke %s' % (str(e)), level=SandeshLevel.SYS_ERR) continue return walk_results # end walk # end class VncCassandraClient class ObjectCacheManager(object): class CachedObject(object): # provide a read-only copy in so far as # top level keys cannot be add/mod/del class RODict(dict): def __readonly__(self, *args, **kwargs): raise RuntimeError("Cannot modify ReadOnlyDict") __setitem__ = __readonly__ __delitem__ = __readonly__ pop = __readonly__ popitem = __readonly__ clear = __readonly__ update = __readonly__ setdefault = __readonly__ del __readonly__ # end RODict def __init__(self, obj_dict, id_perms_ts, row_latest_ts): self.obj_dict = self.RODict(obj_dict) self.id_perms_ts = id_perms_ts self.row_latest_ts = row_latest_ts # end __init__ def update_obj_dict(self, new_obj_dict): self.obj_dict = self.RODict(new_obj_dict) # end update_obj_dict def get_filtered_copy(self, field_names=None): if not field_names: return self.obj_dict # TODO filter with field_names return {k: copy.deepcopy(self.obj_dict[k]) for k in field_names if k in self.obj_dict} # end get_filtered_copy # end class CachedObject def __init__(self, logger, db_client, max_entries, obj_cache_exclude_types=None, debug_obj_cache_types=None): self._logger = logger self.max_entries = max_entries self._db_client = db_client self._cache = OrderedDict() self._obj_cache_exclude_types = set(obj_cache_exclude_types or []) self._debug_obj_cache_types = set(debug_obj_cache_types or []) self._debug_obj_cache_types -= self._obj_cache_exclude_types # end __init__ def _log(self, msg, level=SandeshLevel.SYS_DEBUG): msg = 'Object UUID cache manager: %s' % msg self._logger(msg, level) def evict(self, obj_type, obj_uuids): for obj_uuid in obj_uuids: try: obj_dict = self._cache.pop(obj_uuid).obj_dict if obj_type in self._debug_obj_cache_types: self._log("%s %s (%s) was evicted from cache. Cache " "contained: %s" % ( obj_type.replace('_', '-').title(), ':'.join(obj_dict['fq_name']), obj_uuid, pformat(obj_dict), ), ) except KeyError: continue # end evict def set(self, obj_type, db_rendered_objs, req_fields, include_backrefs_children): # build up results with field filter result_obj_dicts = [] if req_fields: result_fields = set(req_fields) | set(['fq_name', 'uuid', 'parent_type', 'parent_uuid']) for obj_uuid, render_info in list(db_rendered_objs.items()): id_perms_ts = render_info.get('id_perms_ts', 0) row_latest_ts = render_info.get('row_latest_ts', 0) cached_obj = self._cache.pop(obj_uuid, None) if cached_obj is not None: # if we had stale, just update from new db value cached_obj.update_obj_dict(render_info['obj_dict']) cached_obj.id_perms_ts = id_perms_ts if include_backrefs_children: cached_obj.row_latest_ts = row_latest_ts else: # this was a miss in cache cached_obj = self.CachedObject( render_info['obj_dict'], id_perms_ts, row_latest_ts, ) if len(self._cache) >= self.max_entries: # get first element (least recently used) # without getting full copy of dict keys if hasattr(self._cache, 'iterkeys'): key = next(iter(list(self._cache.iterkeys()))) else: # 'keys()' returns an iterator with PY3. key = next(iter(list(self._cache.keys()))) self.evict(obj_type, [key]) self._cache[obj_uuid] = cached_obj if obj_type in self._debug_obj_cache_types: self._log("%s %s (%s) was set in cache with values: %s" % ( obj_type.replace('_', ' ').title(), ':'.join(cached_obj.obj_dict['fq_name']), obj_uuid, pformat(cached_obj.obj_dict), ), ) if req_fields: result_obj_dicts.append( cached_obj.get_filtered_copy(result_fields)) else: result_obj_dicts.append(cached_obj.get_filtered_copy()) # end for all rendered objects return result_obj_dicts # end set def read(self, obj_class, obj_uuids, req_fields, include_backrefs_children): # find which keys are a hit, find which hit keys are not stale # return hit entries and miss+stale uuids. hit_uuids = [] miss_uuids = [] for obj_uuid in obj_uuids: if obj_uuid in self._cache: hit_uuids.append(obj_uuid) else: miss_uuids.append(obj_uuid) stale_uuids = [] # staleness when include_backrefs_children is False = id_perms tstamp # when include_backrefs_children is True = latest_col_ts tstamp if include_backrefs_children: stale_check_col_name = 'META:latest_col_ts' stale_check_ts_attr = 'row_latest_ts' else: stale_check_col_name = 'prop:id_perms' stale_check_ts_attr = 'id_perms_ts' hit_rows_in_db = self._db_client._cassandra_driver.multiget( datastore_api.OBJ_UUID_CF_NAME, hit_uuids, columns=[stale_check_col_name], timestamp=True) obj_dicts = [] result_fields = {'fq_name', 'uuid', 'parent_type', 'parent_uuid'} if req_fields: result_fields = set(req_fields) | result_fields for hit_uuid in hit_uuids: try: obj_cols = hit_rows_in_db[hit_uuid] cached_obj = self._cache[hit_uuid] except KeyError: # Either stale check column missing, treat as miss # Or entry could have been evicted while context switched # for reading stale-check-col, treat as miss miss_uuids.append(hit_uuid) continue if (getattr(cached_obj, stale_check_ts_attr) != obj_cols[stale_check_col_name][1]): miss_uuids.append(hit_uuid) stale_uuids.append(hit_uuid) continue if req_fields: obj_dicts.append(cached_obj.get_filtered_copy(result_fields)) else: obj_dicts.append(cached_obj.get_filtered_copy()) if obj_class.object_type in self._debug_obj_cache_types: obj_rows = self._db_client._cassandra_driver.multiget( datastore_api.OBJ_UUID_CF_NAME, [hit_uuid], timestamp=True) rendered_objs = self._db_client._render_obj_from_db( obj_class, obj_rows, req_fields, include_backrefs_children) db_obj_dict = rendered_objs[hit_uuid]['obj_dict'] self._log("%s %s (%s) was read from cache.\nDB values: %s\n" "Cache value: %s\n" % ( obj_class.object_type.replace('_', ' ').title(), ':'.join(cached_obj.obj_dict['fq_name']), hit_uuid, pformat(db_obj_dict), pformat(cached_obj.obj_dict), ), ) # end for all hit in cache self.evict(obj_class.object_type, stale_uuids) return obj_dicts, miss_uuids # end read def dump_cache(self, obj_uuids=None, count=10): obj_dicts = {} i = 1 if obj_uuids: for obj_uuid in obj_uuids: try: obj = self._cache[obj_uuid] except KeyError: continue obj_json = json.dumps(obj, default=lambda o: dict((k, v) for k, v in list(o.__dict__.items()))) obj_dicts[i] = json.loads(obj_json) i += 1 else: for key in self._cache: if i > count: break obj = self._cache[key] obj_json = json.dumps(obj, default=lambda o: dict((k, v) for k, v in list(o.__dict__.items()))) obj_dicts[i] = json.loads(obj_json) i += 1 return obj_dicts # end class ObjectCacheManager
42.319405
100
0.542985
[ "Apache-2.0" ]
atsgen/tf-controller
src/config/common/cfgm_common/vnc_cassandra.py
73,932
Python
import django import six from django.http import HttpResponseRedirect if django.VERSION[0] < 2: from django.core.urlresolvers import reverse else: from django.urls import reverse from django.db import transaction from django.utils import timezone import logging from processlib.assignment import inherit from processlib.tasks import run_async_activity logger = logging.getLogger(__name__) @six.python_2_unicode_compatible class Activity(object): def __init__( self, flow, process, instance, name, verbose_name=None, permission=None, auto_create_permission=True, permission_name=None, skip_if=None, assign_to=inherit, ): self.flow = flow self.process = process self.verbose_name = verbose_name self.permission = permission self.auto_create_permission = auto_create_permission self.permission_name = permission_name or verbose_name or name self.name = name self.instance = instance # ensure that we have a single referenced process object if self.instance: self.instance.process = self.process self._skip = skip_if self._get_assignment = assign_to def should_skip(self): if not self._skip: return False return self._skip(self) def should_wait(self): return False def has_view(self): return False def __str__(self): return six.text_type(self.verbose_name or self.name) def __repr__(self): return '{}(name="{}")'.format(self.__class__.__name__, self.name) def instantiate( self, predecessor=None, instance_kwargs=None, request=None, **kwargs ): assert not self.instance instance_kwargs = instance_kwargs or {} request_user = ( request.user if request and request.user.is_authenticated else None ) user, group = self._get_assignment( request_user=request_user, predecessor=predecessor ) if "assigned_user" not in instance_kwargs: instance_kwargs["assigned_user"] = user if "assigned_group" not in instance_kwargs: instance_kwargs["assigned_group"] = group self.instance = self.flow.activity_model( process=self.process, activity_name=self.name, **(instance_kwargs or {}) ) self.instance.save() if predecessor: self.instance.predecessors.add(predecessor.instance) def assign_to(self, user, group): self.instance.assigned_user = user self.instance.assigned_group = group self.instance.save() def start(self, **kwargs): assert self.instance.status in ( self.instance.STATUS_INSTANTIATED, self.instance.STATUS_SCHEDULED, ) if not self.instance.started_at: self.instance.started_at = timezone.now() self.instance.status = self.instance.STATUS_STARTED def finish(self, **kwargs): assert self.instance.status == self.instance.STATUS_STARTED if not self.instance.finished_at: self.instance.finished_at = timezone.now() self.instance.status = self.instance.STATUS_DONE self.instance.modified_by = kwargs.get("user", None) self.instance.save() self._instantiate_next_activities() def cancel(self, **kwargs): assert self.instance.status in ( self.instance.STATUS_INSTANTIATED, self.instance.STATUS_ERROR, ) self.instance.status = self.instance.STATUS_CANCELED self.instance.modified_by = kwargs.get("user", None) self.instance.save() def undo(self, **kwargs): assert self.instance.status == self.instance.STATUS_DONE self.instance.finished_at = None self.instance.status = self.instance.STATUS_INSTANTIATED self.instance.modified_by = kwargs.get("user", None) self.instance.save() undo_callback = getattr(self.process, "undo_{}".format(self.name), None) if undo_callback is not None: undo_callback() def error(self, **kwargs): assert self.instance.status != self.instance.STATUS_DONE self.instance.status = self.instance.STATUS_ERROR self.instance.finished_at = timezone.now() self.instance.modified_by = kwargs.get("user", None) self.instance.save() def _get_next_activities(self): for activity_name in self.flow._out_edges[self.name]: activity = self.flow._get_activity_by_name( process=self.process, activity_name=activity_name ) if activity.should_skip(): for later_activity in activity._get_next_activities(): yield later_activity else: yield activity def _instantiate_next_activities(self): for activity in self._get_next_activities(): activity.instantiate(predecessor=self) class State(Activity): """ An activity that simple serves as a marker for a certain state being reached, e.g. if the activity before it was conditional. """ def instantiate(self, **kwargs): super(State, self).instantiate(**kwargs) self.start() self.finish() class ViewActivity(Activity): def __init__(self, view=None, **kwargs): super(ViewActivity, self).__init__(**kwargs) if view is None: raise ValueError( "A ViewActivity requires a view, non given for {}.{}".format( self.flow.label, self.name ) ) self.view = view def has_view(self): return True def get_absolute_url(self): return reverse( "processlib:process-activity", kwargs={"flow_label": self.flow.label, "activity_id": self.instance.pk}, ) def dispatch(self, request, *args, **kwargs): kwargs["activity"] = self return self.view(request, *args, **kwargs) class FunctionActivity(Activity): def __init__(self, callback=None, **kwargs): self.callback = callback super(FunctionActivity, self).__init__(**kwargs) def instantiate(self, **kwargs): super(FunctionActivity, self).instantiate(**kwargs) self.start() def start(self, **kwargs): super(FunctionActivity, self).start(**kwargs) try: self.callback(self) except Exception as e: logger.exception(e) self.error(exception=e) return self.finish() def retry(self): assert self.instance.status == self.instance.STATUS_ERROR self.instance.status = self.instance.STATUS_INSTANTIATED self.instance.finished_at = None self.instance.save() self.start() class AsyncActivity(Activity): def __init__(self, callback=None, **kwargs): self.callback = callback super(AsyncActivity, self).__init__(**kwargs) def instantiate(self, **kwargs): super(AsyncActivity, self).instantiate(**kwargs) self.schedule() def schedule(self, **kwargs): self.instance.status = self.instance.STATUS_SCHEDULED self.instance.scheduled_at = timezone.now() self.instance.save() transaction.on_commit( lambda: run_async_activity.delay(self.flow.label, self.instance.pk) ) def retry(self, **kwargs): assert self.instance.status == self.instance.STATUS_ERROR self.instance.status = self.instance.STATUS_INSTANTIATED self.instance.finished_at = None self.schedule(**kwargs) def start(self, **kwargs): super(AsyncActivity, self).start(**kwargs) self.callback(self) class AsyncViewActivity(AsyncActivity): """ An async activity that renders a view while the async task is running. The view could be AsyncActivityView with a custom template_name """ def __init__(self, view=None, **kwargs): super(AsyncViewActivity, self).__init__(**kwargs) if view is None: raise ValueError( "An AsyncViewActivity requires a view, non given for {}.{}".format( self.flow.label, self.name ) ) self.view = view def has_view(self): return True def get_absolute_url(self): return reverse( "processlib:process-activity", kwargs={"flow_label": self.flow.label, "activity_id": self.instance.pk}, ) def dispatch(self, request, *args, **kwargs): kwargs["activity"] = self return self.view(request, *args, **kwargs) class StartMixin(Activity): def instantiate( self, predecessor=None, instance_kwargs=None, request=None, **kwargs ): assert not self.instance assert not predecessor instance_kwargs = instance_kwargs or {} request_user = ( request.user if request and request.user.is_authenticated else None ) user, group = self._get_assignment( request_user=request_user, predecessor=predecessor ) if "assigned_user" not in instance_kwargs: instance_kwargs["assigned_user"] = user if "assigned_group" not in instance_kwargs: instance_kwargs["assigned_group"] = group self.instance = self.flow.activity_model( process=self.process, activity_name=self.name, **(instance_kwargs or {}) ) def finish(self, **kwargs): assert self.instance.status == self.instance.STATUS_STARTED if not self.instance.finished_at: self.instance.finished_at = timezone.now() self.process.save() self.instance.process = self.process self.instance.status = self.instance.STATUS_DONE self.instance.modified_by = kwargs.get("user", None) self.instance.save() self._instantiate_next_activities() class StartActivity(StartMixin, Activity): pass class StartViewActivity(StartMixin, ViewActivity): pass class EndActivity(Activity): def instantiate(self, **kwargs): super(EndActivity, self).instantiate(**kwargs) self.start() self.finish() def finish(self, **kwargs): super(EndActivity, self).finish(**kwargs) update_fields = [] if not self.process.finished_at: self.process.finished_at = self.instance.finished_at update_fields.append("finished_at") if not self.process.status == self.process.STATUS_DONE: self.process.status = self.process.STATUS_DONE update_fields.append("status") self.process.save(update_fields=update_fields) class EndRedirectActivity(EndActivity): def __init__(self, redirect_url_callback=None, **kwargs): self.redirect_url_callback = redirect_url_callback super(EndActivity, self).__init__(**kwargs) def instantiate(self, **kwargs): # HACK: we skip the EndActivity implementation # because it would finish the activity right away super(EndActivity, self).instantiate(**kwargs) def has_view(self): return True def get_absolute_url(self): return reverse( "processlib:process-activity", kwargs={"flow_label": self.flow.label, "activity_id": self.instance.pk}, ) def dispatch(self, request, *args, **kwargs): self.start() url = reverse( "processlib:process-detail", kwargs={"pk": self.instance.process.pk} ) try: if self.redirect_url_callback: url = self.redirect_url_callback(self) self.finish() except Exception as e: logger.exception(e) self.error(exception=e) return HttpResponseRedirect(url) class FormActivity(Activity): def __init__(self, form_class=None, **kwargs): self.form_class = form_class super(FormActivity, self).__init__(**kwargs) def get_form(self, **kwargs): return self.form_class(**kwargs) class StartFormActivity(StartMixin, FormActivity): pass class IfElse(Activity): def __init__(self, flow, process, instance, name, **kwargs): super(IfElse, self).__init__(flow, process, instance, name, **kwargs) class Wait(Activity): def __init__(self, flow, process, instance, name, **kwargs): wait_for = kwargs.pop("wait_for", None) if not wait_for: raise ValueError("Wait activity needs to wait for something.") super(Wait, self).__init__(flow, process, instance, name, **kwargs) self._wait_for = set(wait_for) if wait_for else None def _find_existing_instance(self, predecessor): candidates = list( self.flow.activity_model.objects.filter( process=self.process, activity_name=self.name ) ) for candidate in candidates: # FIXME this only corrects for simple loops, may fail with more complex scenarios if not candidate.successors.filter( status=candidate.STATUS_DONE, activity_name=self.name ).exists(): return candidate raise self.flow.activity_model.DoesNotExist() def instantiate(self, predecessor=None, instance_kwargs=None, **kwargs): if predecessor is None: raise ValueError("Can't wait for something without a predecessor.") # find the instance try: self.instance = self._find_existing_instance(predecessor) except self.flow.activity_model.DoesNotExist: self.instance = self.flow.activity_model( process=self.process, activity_name=self.name, **(instance_kwargs or {}) ) self.instance.save() self.instance.predecessors.add(predecessor.instance) self.start() def start(self, **kwargs): if not self.instance.started_at: self.instance.started_at = timezone.now() self.instance.status = self.instance.STATUS_STARTED self.instance.save() predecessor_names = { instance.activity_name for instance in self.instance.predecessors.all() } if self._wait_for.issubset(predecessor_names): self.finish()
31.793407
93
0.635144
[ "BSD-3-Clause" ]
RaphaelKimmig/processlib
processlib/activity.py
14,466
Python
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import json import os import sys def update_allure_feature_name(results_dir: str, prefix: str): """Make Allure JSON results unique by pre-pending a prefix to: name, historyId & uuid. Use it when not all of the test results show up in the Allure report. This is because tests from different workers can actually have the same: historyId & uuid values. You can use e.g. browser name as the prefix. """ results_dir_path = os.path.join(".", results_dir) update_count = 0 for filename in os.listdir(results_dir_path): if filename.endswith(".json"): result_file = os.path.join(results_dir_path, filename) with open(result_file, "r") as json_file: report = json.loads(json_file.read()) report["name"] = f"{prefix} - {report['name']}" report["historyId"] = f"{prefix}{report['historyId']}" report["uuid"] = f"{prefix}{report['uuid']}" with open(result_file, "w") as json_file: json.dump(report, json_file, indent=2, ensure_ascii=False) update_count += 1 print(f"Updated {update_count} JSON reports") if __name__ == "__main__": update_allure_feature_name(results_dir=sys.argv[1], prefix=sys.argv[2])
38.941176
101
0.638218
[ "Apache-2.0" ]
tomaszwozniak/behave-docker-parallel
update_results.py
1,324
Python
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations class Migration(migrations.Migration): dependencies = [ ('forms', '0016_auto_20150330_1413'), ] operations = [ migrations.AlterField( model_name='radiosheet', name='item_number', field=models.PositiveIntegerField(help_text='Write in the number that describes the position of the story within the newscast. E.g. the first story in the newscast is item 1; the seventh story is item 7.', verbose_name='(1) Item Number', choices=[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10), (11, 11), (12, 12), (13, 13), (14, 14), (15, 15), (16, 16), (17, 17), (18, 18), (19, 19), (20, 20), (21, 21), (22, 22), (23, 23), (24, 24), (25, 25), (26, 26), (27, 27), (28, 28), (29, 29)]), preserve_default=True, ), migrations.AlterField( model_name='televisionsheet', name='item_number', field=models.PositiveIntegerField(help_text='Write in the number that describes the position of the story within the newscast. E.g. the first story in the newscast is item 1; the seventh story is item 7.', verbose_name='(1) Item Number', choices=[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10), (11, 11), (12, 12), (13, 13), (14, 14), (15, 15), (16, 16), (17, 17), (18, 18), (19, 19), (20, 20), (21, 21), (22, 22), (23, 23), (24, 24), (25, 25), (26, 26), (27, 27), (28, 28), (29, 29)]), preserve_default=True, ), ]
59.62963
532
0.560248
[ "Apache-2.0" ]
Code4SA/gmmp
forms/migrations/0017_auto_20150331_1815.py
1,610
Python
# coding=utf-8 # *** WARNING: this file was generated by the Pulumi SDK Generator. *** # *** Do not edit by hand unless you're certain you know what you are doing! *** import warnings import pulumi import pulumi.runtime from typing import Any, Mapping, Optional, Sequence, Union, overload from .. import _utilities from . import outputs from ._inputs import * __all__ = ['PrivateEndpointConnectionArgs', 'PrivateEndpointConnection'] @pulumi.input_type class PrivateEndpointConnectionArgs: def __init__(__self__, *, factory_name: pulumi.Input[str], resource_group_name: pulumi.Input[str], private_endpoint_connection_name: Optional[pulumi.Input[str]] = None, properties: Optional[pulumi.Input['PrivateLinkConnectionApprovalRequestArgs']] = None): """ The set of arguments for constructing a PrivateEndpointConnection resource. :param pulumi.Input[str] factory_name: The factory name. :param pulumi.Input[str] resource_group_name: The resource group name. :param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name. :param pulumi.Input['PrivateLinkConnectionApprovalRequestArgs'] properties: Core resource properties """ pulumi.set(__self__, "factory_name", factory_name) pulumi.set(__self__, "resource_group_name", resource_group_name) if private_endpoint_connection_name is not None: pulumi.set(__self__, "private_endpoint_connection_name", private_endpoint_connection_name) if properties is not None: pulumi.set(__self__, "properties", properties) @property @pulumi.getter(name="factoryName") def factory_name(self) -> pulumi.Input[str]: """ The factory name. """ return pulumi.get(self, "factory_name") @factory_name.setter def factory_name(self, value: pulumi.Input[str]): pulumi.set(self, "factory_name", value) @property @pulumi.getter(name="resourceGroupName") def resource_group_name(self) -> pulumi.Input[str]: """ The resource group name. """ return pulumi.get(self, "resource_group_name") @resource_group_name.setter def resource_group_name(self, value: pulumi.Input[str]): pulumi.set(self, "resource_group_name", value) @property @pulumi.getter(name="privateEndpointConnectionName") def private_endpoint_connection_name(self) -> Optional[pulumi.Input[str]]: """ The private endpoint connection name. """ return pulumi.get(self, "private_endpoint_connection_name") @private_endpoint_connection_name.setter def private_endpoint_connection_name(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "private_endpoint_connection_name", value) @property @pulumi.getter def properties(self) -> Optional[pulumi.Input['PrivateLinkConnectionApprovalRequestArgs']]: """ Core resource properties """ return pulumi.get(self, "properties") @properties.setter def properties(self, value: Optional[pulumi.Input['PrivateLinkConnectionApprovalRequestArgs']]): pulumi.set(self, "properties", value) class PrivateEndpointConnection(pulumi.CustomResource): @overload def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, factory_name: Optional[pulumi.Input[str]] = None, private_endpoint_connection_name: Optional[pulumi.Input[str]] = None, properties: Optional[pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']]] = None, resource_group_name: Optional[pulumi.Input[str]] = None, __props__=None): """ Private Endpoint Connection ARM resource. API Version: 2018-06-01. :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[str] factory_name: The factory name. :param pulumi.Input[str] private_endpoint_connection_name: The private endpoint connection name. :param pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']] properties: Core resource properties :param pulumi.Input[str] resource_group_name: The resource group name. """ ... @overload def __init__(__self__, resource_name: str, args: PrivateEndpointConnectionArgs, opts: Optional[pulumi.ResourceOptions] = None): """ Private Endpoint Connection ARM resource. API Version: 2018-06-01. :param str resource_name: The name of the resource. :param PrivateEndpointConnectionArgs args: The arguments to use to populate this resource's properties. :param pulumi.ResourceOptions opts: Options for the resource. """ ... def __init__(__self__, resource_name: str, *args, **kwargs): resource_args, opts = _utilities.get_resource_args_opts(PrivateEndpointConnectionArgs, pulumi.ResourceOptions, *args, **kwargs) if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, factory_name: Optional[pulumi.Input[str]] = None, private_endpoint_connection_name: Optional[pulumi.Input[str]] = None, properties: Optional[pulumi.Input[pulumi.InputType['PrivateLinkConnectionApprovalRequestArgs']]] = None, resource_group_name: Optional[pulumi.Input[str]] = None, __props__=None): if opts is None: opts = pulumi.ResourceOptions() if not isinstance(opts, pulumi.ResourceOptions): raise TypeError('Expected resource options to be a ResourceOptions instance') if opts.version is None: opts.version = _utilities.get_version() if opts.id is None: if __props__ is not None: raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') __props__ = PrivateEndpointConnectionArgs.__new__(PrivateEndpointConnectionArgs) if factory_name is None and not opts.urn: raise TypeError("Missing required property 'factory_name'") __props__.__dict__["factory_name"] = factory_name __props__.__dict__["private_endpoint_connection_name"] = private_endpoint_connection_name __props__.__dict__["properties"] = properties if resource_group_name is None and not opts.urn: raise TypeError("Missing required property 'resource_group_name'") __props__.__dict__["resource_group_name"] = resource_group_name __props__.__dict__["etag"] = None __props__.__dict__["name"] = None __props__.__dict__["type"] = None alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-nextgen:datafactory:PrivateEndpointConnection"), pulumi.Alias(type_="azure-native:datafactory/v20180601:PrivateEndpointConnection"), pulumi.Alias(type_="azure-nextgen:datafactory/v20180601:PrivateEndpointConnection")]) opts = pulumi.ResourceOptions.merge(opts, alias_opts) super(PrivateEndpointConnection, __self__).__init__( 'azure-native:datafactory:PrivateEndpointConnection', resource_name, __props__, opts) @staticmethod def get(resource_name: str, id: pulumi.Input[str], opts: Optional[pulumi.ResourceOptions] = None) -> 'PrivateEndpointConnection': """ Get an existing PrivateEndpointConnection resource's state with the given name, id, and optional extra properties used to qualify the lookup. :param str resource_name: The unique name of the resulting resource. :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. :param pulumi.ResourceOptions opts: Options for the resource. """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) __props__ = PrivateEndpointConnectionArgs.__new__(PrivateEndpointConnectionArgs) __props__.__dict__["etag"] = None __props__.__dict__["name"] = None __props__.__dict__["properties"] = None __props__.__dict__["type"] = None return PrivateEndpointConnection(resource_name, opts=opts, __props__=__props__) @property @pulumi.getter def etag(self) -> pulumi.Output[str]: """ Etag identifies change in the resource. """ return pulumi.get(self, "etag") @property @pulumi.getter def name(self) -> pulumi.Output[str]: """ The resource name. """ return pulumi.get(self, "name") @property @pulumi.getter def properties(self) -> pulumi.Output['outputs.RemotePrivateEndpointConnectionResponse']: """ Core resource properties """ return pulumi.get(self, "properties") @property @pulumi.getter def type(self) -> pulumi.Output[str]: """ The resource type. """ return pulumi.get(self, "type")
43.659091
297
0.669755
[ "Apache-2.0" ]
polivbr/pulumi-azure-native
sdk/python/pulumi_azure_native/datafactory/private_endpoint_connection.py
9,605
Python
# By @HYPER-MOD from PIL import Image, ImageEnhance, ImageDraw import numpy as np import os import cv2 import shutil async def circle_with_bg(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "circle.png" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") img = Image.open(a).convert("RGB") npImage = np.array(img) h, w = img.size alpha = Image.new("L", img.size, 0) draw = ImageDraw.Draw(alpha) draw.pieslice([0, 0, h, w], 0, 360, fill=255) npAlpha = np.array(alpha) npImage = np.dstack((npImage, npAlpha)) Image.fromarray(npImage).save(edit_img_loc) await message.reply_chat_action("upload_photo") await message.reply_to_message.reply_photo(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("circle_with_bg-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return async def circle_without_bg(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "circle.png" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") img = Image.open(a).convert("RGB") npImage = np.array(img) h, w = img.size alpha = Image.new("L", img.size, 0) draw = ImageDraw.Draw(alpha) draw.pieslice([0, 0, h, w], 0, 360, fill=255) npAlpha = np.array(alpha) npImage = np.dstack((npImage, npAlpha)) Image.fromarray(npImage).save(edit_img_loc) await message.reply_chat_action("upload_document") await message.reply_to_message.reply_document(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("circle_without_bg-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return async def sticker(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "sticker.webp" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") os.rename(a, edit_img_loc) await message.reply_to_message.reply_sticker(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("sticker-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return def add_corners(im, rad): circle = Image.new("L", (rad * 2, rad * 2), 0) draw = ImageDraw.Draw(circle) draw.ellipse((0, 0, rad * 2, rad * 2), fill=255) alpha = Image.new("L", im.size, 255) w, h = im.size alpha.paste(circle.crop((0, 0, rad, rad)), (0, 0)) alpha.paste(circle.crop((0, rad, rad, rad * 2)), (0, h - rad)) alpha.paste(circle.crop((rad, 0, rad * 2, rad)), (w - rad, 0)) alpha.paste(circle.crop((rad, rad, rad * 2, rad * 2)), (w - rad, h - rad)) im.putalpha(alpha) return im async def edge_curved(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "edge_curved.webp" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") im = Image.open(a) im = add_corners(im, 100) im.save(edit_img_loc) await message.reply_chat_action("upload_photo") await message.reply_to_message.reply_sticker(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("edge_curved-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return async def contrast(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "contrast.jpg" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") image = Image.open(a) contrast = ImageEnhance.Contrast(image) contrast.enhance(1.5).save(edit_img_loc) await message.reply_chat_action("upload_photo") await message.reply_to_message.reply_photo(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("contrast-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return def sepia(img): width, height = img.size new_img = img.copy() for x in range(width): for y in range(height): red, green, blue = img.getpixel((x, y)) new_val = 0.3 * red + 0.59 * green + 0.11 * blue new_red = int(new_val * 2) if new_red > 255: new_red = 255 new_green = int(new_val * 1.5) if new_green > 255: new_green = 255 new_blue = int(new_val) if new_blue > 255: new_blue = 255 new_img.putpixel((x, y), (new_red, new_green, new_blue)) return new_img async def sepia_mode(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "sepia.jpg" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") image = Image.open(a) new_img = sepia(image) new_img.save(edit_img_loc) await message.reply_chat_action("upload_photo") await message.reply_to_message.reply_photo(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("sepia_mode-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return def dodgeV2(x, y): return cv2.divide(x, 255 - y, scale=256) async def pencil(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "pencil.jpg" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") img = cv2.imread(a) img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) img_invert = cv2.bitwise_not(img_gray) img_smoothing = cv2.GaussianBlur(img_invert, (21, 21), sigmaX=0, sigmaY=0) final_img = dodgeV2(img_gray, img_smoothing) cv2.imwrite(edit_img_loc, final_img) await message.reply_chat_action("upload_photo") await message.reply_to_message.reply_photo(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("pencil-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return def color_quantization(img, k): data = np.float32(img).reshape((-1, 3)) criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 1.0) _, label, center = cv2.kmeans( data, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS ) center = np.uint8(center) result = center[label.flatten()] result = result.reshape(img.shape) return result async def cartoon(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "kang.jpg" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True ) a = await client.download_media( message=message.reply_to_message, file_name=download_location ) await msg.edit("Processing Image...") img = cv2.imread(a) edges = cv2.Canny(img, 100, 200) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) edges = cv2.adaptiveThreshold( gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 5 ) color = cv2.bilateralFilter(img, d=9, sigmaColor=200, sigmaSpace=200) cv2.bitwise_and(color, color, mask=edges) img_1 = color_quantization(img, 7) cv2.imwrite(edit_img_loc, img_1) await message.reply_chat_action("upload_photo") await message.reply_to_message.reply_photo(edit_img_loc, quote=True) await msg.delete() else: await message.reply_text("Why did you delete that??") try: shutil.rmtree(f"./DOWNLOADS/{userid}") except Exception: pass except Exception as e: print("cartoon-error - " + str(e)) if "USER_IS_BLOCKED" in str(e): return else: try: await message.reply_to_message.reply_text( "Something went wrong!", quote=True ) except Exception: return
37.626566
86
0.550057
[ "MIT" ]
HYPER-MODZ/image-editor-bot
image/edit_2.py
15,013
Python
#!/usr/bin/env python # coding: utf-8 # # WORKFLOW PROCEDURE # In[ ]: # import utilities from ds_utils import * # to plot results get_ipython().run_line_magic('matplotlib', 'inline') # ## How to use this code: # # ### Step 1 # # From a list of train and test datasets run the baseline_generator function and check the results # in the output file. This file is sorted by AUC value in each dataset and algorithm. You should probably need to # run the ROC_baseline_plot as well to get a visualization of the previous baseline results. This will give us # an idea of the general performances. So the next step should be optimized the best model(s) using the best dataset # according to the previous results. If you want to optimized more than one model they can be stored into a list to use a grid search # in all models by using the nestedCV function # # # ### Step 2 # # Pick the dataset and the algorithm to optimized and pass them to the nestedCV function. This function will find the best combination of # parameters and train a model based on it. As an output the fitted model will be returned, so there is no need to fit the model again. This # output could be used in the next step testing these models on a unseen test set which was not used in the nestedCV phase. # # # ### Step 3 # # From a list of optimized model by the nesteCV funtion, predict classes using an unseen test set using the check_predictions_unseen_test_set. # This function will return a file which is sorted by AUC value as well as a roc curve plot. This file will tell us the model which achieves better performance in the # test set. # # # ### Step 4 # # Further analysis plotting some graphs such as ROC curve, PR, etc.. # In[ ]: # set list of train and test files listFiles_tr = ['minitrain.csv', 's.ds_MA_tr.csv'] listFiles_ts = ['minitest.csv', 's.ds_MA_ts.csv'] # run a baseline with datasets from above baseline_generator(listFiles_tr, listFiles_ts) # In[ ]: # plot the ROC curves for the dataset which achieves the best performance # as we can see 'minitrain.csv' is the dataset which seems to get better performances # so let's plot roc curves on it. newFile_tr = 'minitrain.csv' # new training data newFile_ts = 'minitest.csv' # new testing data ROC_baseline_plot(newFile_tr, newFile_ts) # According to this baseline results it seems that GradientBoostingClassifier is a good candidate as is one of the model with higher AUC, so we can try to optimize its parameters on the minitrain dataset since is the one the suits better GradientBoostingClassifier. For simplicity we will look for parameters on an algorithm which is faster to train, let's say Logistics Regression and another one more complex such as Random Forest. # # So we should proceed as follows: # Once we have decided to use a dataset we can extract its values only once. By doing this we can use some # useful functions like the ones described below # In[ ]: # Since now we were using just one dataset. So we keep newFile_tr and newFile_ts from above # Get data from that datasets values = datasets_parser(newFile_tr, newFile_ts, outVar=outVar) X_tr_data = values[0] # X_train data y_tr_data = values[1] # y_train data X_ts_data = values[2] # X_test data y_ts_data = values[3] # y_test data # In[ ]: def gridsearchCV_strategy(X_tr_data, y_tr_data, list_estimators, list_params): """ len of list_estimators and list_params should be the same. For any estimator you need a list of parameters to optimize. Eg list_estimators = [RandomForestClassifier(), LogisticRegression()] list_params = [{'n_estimators': [500,1000], 'max_features': [8,10], 'max_depth' : [4,6,8], 'criterion' :['gini', 'entropy']},'C': [100, 1000], 'solver' : ['lbfgs'], 'max_iter' : [1000, 2000], 'n_jobs' : [-1] }] """ # First check if both lists has the same length if len(list_estimators) != len(list_params): raise ValueError("list_estimators and list_params must have the same length") # Estimate weights in the data used to look for parameters class_weights = set_weights(y_tr_data) # iterate through the list of estimators to see if any of them has some parameters such as random_state or # class_weight or n_jobs, if so we will set them to the chosen seed for the running task and the weights estimated # into this function which will be the ones obtained from the training data used. for est in list_estimators: est_params = est.get_params() if 'class_weight' in est_params: est.set_params(class_weight = class_weights) if 'n_jobs' in est_params: est.set_params(n_jobs = -1) if 'random_state' in est_params: est.set_params(random_state = seed) dict_estimators_to_optimize = {} for estimator, parameters in zip(list_estimators, list_params): dict_estimators_to_optimize[estimator] = parameters list_optimized_models = [nestedCV(estimator, X_tr_data, y_tr_data, param_grid=parameters) for estimator, parameters in dict_estimators_to_optimize.items()] #check which params were used in the list_optimized_models #for op_model in list_optimized_models: # print(op_model.get_params()) return list_optimized_models # In[ ]: # Example of execution list_estimators = [RandomForestClassifier(),LogisticRegression()] list_params = [{'n_estimators': [500], 'max_features': [8], 'max_depth' : [8], 'criterion' :['entropy']}, {'C': [1000], 'solver' : ['lbfgs'], 'max_iter' : [200] }] list_optimized_models = gridsearchCV_strategy(X_tr_data, y_tr_data, list_estimators, list_params) # Converge warning are due to the scale of the dataset. It would be converge faster using standar_scaler # transformation from scikit-learn # In[ ]: # Make predictions on unseen dataset check_predictions_unseen_test_set(list_optimized_models, X_ts_data, y_ts_data, newFile_ts) # In[ ]:
35.111732
436
0.694829
[ "Apache-2.0" ]
kennethriva/Machine-Learning-for-drugs-cytokines
workflow_procedure_example.py
6,285
Python
import logging from logging import basicConfig, getLogger from lib import do_something def main(): log_fmt = "%(asctime)s - %(name)s - %(levelname)s - %(message)s" basicConfig(format=log_fmt, level="DEBUG") logger = getLogger(__name__) for i in range(3): logger.info("---------------{}-th trial------------".format(i)) logger.debug("debugging...") logger.info("tell information") logger.warn("warn it comes from something like ...") logger.error("Ops some error is occured") logger.critical("critical event happened") logger.debug("It's raining again") logger.info("with hail the size of hailstones") do_something() if __name__ == '__main__': main()
28.296296
71
0.602094
[ "MIT" ]
terasakisatoshi/pythonCodes
loggingExer/moduleExer/start.py
764
Python
# pylint:disable=unused-variable # pylint:disable=unused-argument # pylint:disable=redefined-outer-name # pylint:disable=protected-access import json import re import urllib.parse from collections import namedtuple from pathlib import Path from random import randint from typing import Callable, List from uuid import uuid4 import pytest import respx from fastapi import FastAPI, status from models_library.services import ServiceDockerData, ServiceKeyVersion from simcore_service_director_v2.models.schemas.services import ( RunningServiceDetails, ServiceExtras, ) from simcore_service_director_v2.modules.director_v0 import DirectorV0Client @pytest.fixture(autouse=True) def minimal_director_config(project_env_devel_environment, monkeypatch): """set a minimal configuration for testing the director connection only""" monkeypatch.setenv("DIRECTOR_ENABLED", "1") monkeypatch.setenv("POSTGRES_ENABLED", "0") monkeypatch.setenv("CELERY_ENABLED", "0") monkeypatch.setenv("REGISTRY_ENABLED", "0") @pytest.fixture def mocked_director_v0_service_api(minimal_app, entrypoint, exp_data, resp_alias): with respx.mock( base_url=minimal_app.state.settings.director_v0.base_url(include_tag=False), assert_all_called=False, assert_all_mocked=True, ) as respx_mock: # lists services respx_mock.get( urllib.parse.unquote(entrypoint), content=exp_data, alias=resp_alias, ) yield respx_mock ForwardToDirectorParams = namedtuple( "ForwardToDirectorParams", "entrypoint,exp_status,exp_data,resp_alias" ) def _get_list_services_calls() -> List[ForwardToDirectorParams]: return [ ForwardToDirectorParams( entrypoint="/v0/services", exp_status=status.HTTP_200_OK, exp_data={"data": ["service1", "service2"]}, resp_alias="list_all_services", ), ForwardToDirectorParams( entrypoint="/v0/services?service_type=computational", exp_status=status.HTTP_200_OK, exp_data={"data": ["service1", "service2"]}, resp_alias="list_computational_services", ), ForwardToDirectorParams( entrypoint="/v0/services?service_type=dynamic", exp_status=status.HTTP_200_OK, exp_data={"data": ["service1", "service2"]}, resp_alias="list_dynamic_services", ), ] def _get_service_version_calls() -> List[ForwardToDirectorParams]: # TODO: here we see the return value is currently not validated return [ ForwardToDirectorParams( entrypoint="/v0/services/simcore%2Fservices%2Fdynamic%2Fmyservice/1.3.4", exp_status=status.HTTP_200_OK, exp_data={"data": ["stuff about my service"]}, resp_alias="get_service_version", ) ] def _get_service_version_extras_calls() -> List[ForwardToDirectorParams]: # TODO: here we see the return value is currently not validated return [ ForwardToDirectorParams( entrypoint="/v0/services/simcore%2Fservices%2Fdynamic%2Fmyservice/1.3.4/extras", exp_status=status.HTTP_200_OK, exp_data={"data": "extra stuff about my service"}, resp_alias="get_service_extras", ) ] @pytest.mark.parametrize( "entrypoint,exp_status,exp_data,resp_alias", _get_list_services_calls() + _get_service_version_calls() + _get_service_version_extras_calls(), ) def test_forward_to_director( client, mocked_director_v0_service_api, entrypoint, exp_status, exp_data, resp_alias ): response = client.get(entrypoint) assert response.status_code == exp_status assert response.json() == exp_data assert mocked_director_v0_service_api[resp_alias].called @pytest.fixture(scope="session") def fake_service_details(mocks_dir: Path) -> ServiceDockerData: fake_service_path = mocks_dir / "fake_service.json" assert fake_service_path.exists() fake_service_data = json.loads(fake_service_path.read_text()) return ServiceDockerData(**fake_service_data) @pytest.fixture def fake_service_extras(random_json_from_schema: Callable) -> ServiceExtras: random_extras = ServiceExtras( **random_json_from_schema(ServiceExtras.schema_json(indent=2)) ) return random_extras @pytest.fixture def fake_running_service_details( random_json_from_schema: Callable, ) -> RunningServiceDetails: random_data = random_json_from_schema(RunningServiceDetails.schema_json(indent=2)) # fix port stuff, the randomiser does not understand positive ints KEYS_TO_FIX = ["published_port", "service_port"] for k in KEYS_TO_FIX: if k in random_data: random_data[k] = randint(1, 50000) random_details = RunningServiceDetails(**random_data) return random_details @pytest.fixture def mocked_director_service_fcts( minimal_app: FastAPI, fake_service_details: ServiceDockerData, fake_service_extras: ServiceExtras, fake_running_service_details: RunningServiceDetails, ): with respx.mock( base_url=minimal_app.state.settings.director_v0.base_url(include_tag=False), assert_all_called=False, assert_all_mocked=True, ) as respx_mock: respx_mock.get( "/v0/services/simcore%2Fservices%2Fdynamic%2Fmyservice/1.3.4", content={"data": [fake_service_details.dict(by_alias=True)]}, alias="get_service_version", ) respx_mock.get( "/v0/service_extras/simcore%2Fservices%2Fdynamic%2Fmyservice/1.3.4", content={"data": fake_service_extras.dict(by_alias=True)}, alias="get_service_extras", ) pattern = re.compile( r"v0/running_interactive_services/[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}$" ) respx_mock.get( pattern, content={"data": fake_running_service_details.dict(by_alias=True)}, alias="get_running_service_details", ) yield respx_mock async def test_get_service_details( minimal_app: FastAPI, mocked_director_service_fcts, fake_service_details: ServiceDockerData, ): director_client: DirectorV0Client = minimal_app.state.director_v0_client service = ServiceKeyVersion( key="simcore/services/dynamic/myservice", version="1.3.4" ) service_details: ServiceDockerData = await director_client.get_service_details( service ) assert mocked_director_service_fcts["get_service_version"].called assert fake_service_details == service_details async def test_get_service_extras( minimal_app: FastAPI, mocked_director_service_fcts, fake_service_extras: ServiceExtras, ): director_client: DirectorV0Client = minimal_app.state.director_v0_client service = ServiceKeyVersion( key="simcore/services/dynamic/myservice", version="1.3.4" ) service_extras: ServiceExtras = await director_client.get_service_extras(service) assert mocked_director_service_fcts["get_service_extras"].called assert fake_service_extras == service_extras async def test_get_running_service_details( minimal_app: FastAPI, mocked_director_service_fcts, fake_running_service_details: RunningServiceDetails, ): director_client: DirectorV0Client = minimal_app.state.director_v0_client service_details: RunningServiceDetails = ( await director_client.get_running_service_details(str(uuid4())) ) assert mocked_director_service_fcts["get_running_service_details"].called assert fake_running_service_details == service_details
33.733624
127
0.71767
[ "MIT" ]
GitHK/osparc-simcore-forked
services/director-v2/tests/unit/test_modules_director_v0.py
7,725
Python
#!/usr/bin/env python3 # Copyright (c) 2015-2018 The Dash Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. from test_framework.blocktools import get_masternode_payment, create_coinbase, create_block from test_framework.mininode import * from test_framework.test_framework import cryptocauseTestFramework from test_framework.util import * from time import * ''' llmq-is-cl-conflicts.py Checks conflict handling between ChainLocks and InstantSend ''' class TestNode(SingleNodeConnCB): def __init__(self): SingleNodeConnCB.__init__(self) self.clsigs = {} self.islocks = {} def send_clsig(self, clsig): hash = uint256_from_str(hash256(clsig.serialize())) self.clsigs[hash] = clsig inv = msg_inv([CInv(29, hash)]) self.send_message(inv) def send_islock(self, islock): hash = uint256_from_str(hash256(islock.serialize())) self.islocks[hash] = islock inv = msg_inv([CInv(30, hash)]) self.send_message(inv) def on_getdata(self, conn, message): for inv in message.inv: if inv.hash in self.clsigs: self.send_message(self.clsigs[inv.hash]) if inv.hash in self.islocks: self.send_message(self.islocks[inv.hash]) class LLMQ_IS_CL_Conflicts(cryptocauseTestFramework): def __init__(self): super().__init__(6, 5, [], fast_dip3_enforcement=True) #disable_mocktime() def run_test(self): while self.nodes[0].getblockchaininfo()["bip9_softforks"]["dip0008"]["status"] != "active": self.nodes[0].generate(10) sync_blocks(self.nodes, timeout=60*5) self.test_node = TestNode() self.test_node.add_connection(NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], self.test_node)) NetworkThread().start() # Start up network handling in another thread self.test_node.wait_for_verack() self.nodes[0].spork("SPORK_17_QUORUM_DKG_ENABLED", 0) self.nodes[0].spork("SPORK_19_CHAINLOCKS_ENABLED", 0) self.nodes[0].spork("SPORK_20_INSTANTSEND_LLMQ_BASED", 0) self.wait_for_sporks_same() self.mine_quorum() # mine single block, wait for chainlock self.nodes[0].generate(1) self.wait_for_chainlock_tip_all_nodes() self.test_chainlock_overrides_islock(False) self.test_chainlock_overrides_islock(True) self.test_islock_overrides_nonchainlock() def test_chainlock_overrides_islock(self, test_block_conflict): # create three raw TXs, they will conflict with each other rawtx1 = self.create_raw_tx(self.nodes[0], self.nodes[0], 1, 1, 100)['hex'] rawtx2 = self.create_raw_tx(self.nodes[0], self.nodes[0], 1, 1, 100)['hex'] rawtx3 = self.create_raw_tx(self.nodes[0], self.nodes[0], 1, 1, 100)['hex'] rawtx1_obj = FromHex(CTransaction(), rawtx1) rawtx2_obj = FromHex(CTransaction(), rawtx2) rawtx3_obj = FromHex(CTransaction(), rawtx3) rawtx1_txid = self.nodes[0].sendrawtransaction(rawtx1) rawtx2_txid = encode(hash256(hex_str_to_bytes(rawtx2))[::-1], 'hex_codec').decode('ascii') rawtx3_txid = encode(hash256(hex_str_to_bytes(rawtx3))[::-1], 'hex_codec').decode('ascii') # Create a chained TX on top of tx1 inputs = [] n = 0 for out in rawtx1_obj.vout: if out.nValue == 100000000: inputs.append({"txid": rawtx1_txid, "vout": n}) n += 1 rawtx4 = self.nodes[0].createrawtransaction(inputs, {self.nodes[0].getnewaddress(): 0.999}) rawtx4 = self.nodes[0].signrawtransaction(rawtx4)['hex'] rawtx4_txid = self.nodes[0].sendrawtransaction(rawtx4) for node in self.nodes: self.wait_for_instantlock(rawtx1_txid, node) self.wait_for_instantlock(rawtx4_txid, node) block = self.create_block(self.nodes[0], [rawtx2_obj]) if test_block_conflict: submit_result = self.nodes[0].submitblock(ToHex(block)) assert(submit_result == "conflict-tx-lock") cl = self.create_chainlock(self.nodes[0].getblockcount() + 1, block.sha256) self.test_node.send_clsig(cl) # Give the CLSIG some time to propagate. We unfortunately can't check propagation here as "getblock/getblockheader" # is required to check for CLSIGs, but this requires the block header to be propagated already sleep(1) # The block should get accepted now, and at the same time prune the conflicting ISLOCKs submit_result = self.nodes[1].submitblock(ToHex(block)) if test_block_conflict: assert(submit_result == "duplicate") else: assert(submit_result is None) for node in self.nodes: self.wait_for_chainlock(node, "%064x" % block.sha256) # Create a chained TX on top of tx2 inputs = [] n = 0 for out in rawtx2_obj.vout: if out.nValue == 100000000: inputs.append({"txid": rawtx2_txid, "vout": n}) n += 1 rawtx5 = self.nodes[0].createrawtransaction(inputs, {self.nodes[0].getnewaddress(): 0.999}) rawtx5 = self.nodes[0].signrawtransaction(rawtx5)['hex'] rawtx5_txid = self.nodes[0].sendrawtransaction(rawtx5) for node in self.nodes: self.wait_for_instantlock(rawtx5_txid, node) # Lets verify that the ISLOCKs got pruned for node in self.nodes: assert_raises_jsonrpc(-5, "No such mempool or blockchain transaction", node.getrawtransaction, rawtx1_txid, True) assert_raises_jsonrpc(-5, "No such mempool or blockchain transaction", node.getrawtransaction, rawtx4_txid, True) rawtx = node.getrawtransaction(rawtx2_txid, True) assert(rawtx['chainlock']) assert(rawtx['instantlock']) assert(not rawtx['instantlock_internal']) def test_islock_overrides_nonchainlock(self): # create two raw TXs, they will conflict with each other rawtx1 = self.create_raw_tx(self.nodes[0], self.nodes[0], 1, 1, 100)['hex'] rawtx2 = self.create_raw_tx(self.nodes[0], self.nodes[0], 1, 1, 100)['hex'] rawtx1_txid = encode(hash256(hex_str_to_bytes(rawtx1))[::-1], 'hex_codec').decode('ascii') rawtx2_txid = encode(hash256(hex_str_to_bytes(rawtx2))[::-1], 'hex_codec').decode('ascii') # Create an ISLOCK but don't broadcast it yet islock = self.create_islock(rawtx2) # Stop enough MNs so that ChainLocks don't work anymore for i in range(3): self.stop_node(len(self.nodes) - 1) self.nodes.pop(len(self.nodes) - 1) self.mninfo.pop(len(self.mninfo) - 1) # Send tx1, which will later conflict with the ISLOCK self.nodes[0].sendrawtransaction(rawtx1) # fast forward 11 minutes, so that the TX is considered safe and included in the next block set_mocktime(get_mocktime() + int(60 * 11)) set_node_times(self.nodes, get_mocktime()) # Mine the conflicting TX into a block good_tip = self.nodes[0].getbestblockhash() self.nodes[0].generate(2) self.sync_all() # Assert that the conflicting tx got mined and the locked TX is not valid assert(self.nodes[0].getrawtransaction(rawtx1_txid, True)['confirmations'] > 0) assert_raises_jsonrpc(-25, "Missing inputs", self.nodes[0].sendrawtransaction, rawtx2) # Send the ISLOCK, which should result in the last 2 blocks to be invalidated, even though the nodes don't know # the locked transaction yet self.test_node.send_islock(islock) sleep(5) assert(self.nodes[0].getbestblockhash() == good_tip) assert(self.nodes[1].getbestblockhash() == good_tip) # Send the actual transaction and mine it self.nodes[0].sendrawtransaction(rawtx2) self.nodes[0].generate(1) self.sync_all() assert(self.nodes[0].getrawtransaction(rawtx2_txid, True)['confirmations'] > 0) assert(self.nodes[1].getrawtransaction(rawtx2_txid, True)['confirmations'] > 0) assert(self.nodes[0].getrawtransaction(rawtx2_txid, True)['instantlock']) assert(self.nodes[1].getrawtransaction(rawtx2_txid, True)['instantlock']) assert(self.nodes[0].getbestblockhash() != good_tip) assert(self.nodes[1].getbestblockhash() != good_tip) def wait_for_chainlock_tip_all_nodes(self): for node in self.nodes: tip = node.getbestblockhash() self.wait_for_chainlock(node, tip) def wait_for_chainlock_tip(self, node): tip = node.getbestblockhash() self.wait_for_chainlock(node, tip) def wait_for_chainlock(self, node, block_hash): t = time() while time() - t < 15: try: block = node.getblockheader(block_hash) if block["confirmations"] > 0 and block["chainlock"]: return except: # block might not be on the node yet pass sleep(0.1) raise AssertionError("wait_for_chainlock timed out") def create_block(self, node, vtx=[]): bt = node.getblocktemplate() height = bt['height'] tip_hash = bt['previousblockhash'] coinbasevalue = bt['coinbasevalue'] miner_address = node.getnewaddress() mn_payee = bt['masternode'][0]['payee'] # calculate fees that the block template included (we'll have to remove it from the coinbase as we won't # include the template's transactions bt_fees = 0 for tx in bt['transactions']: bt_fees += tx['fee'] new_fees = 0 for tx in vtx: in_value = 0 out_value = 0 for txin in tx.vin: txout = node.gettxout("%064x" % txin.prevout.hash, txin.prevout.n, False) in_value += int(txout['value'] * COIN) for txout in tx.vout: out_value += txout.nValue new_fees += in_value - out_value # fix fees coinbasevalue -= bt_fees coinbasevalue += new_fees mn_amount = get_masternode_payment(height, coinbasevalue) miner_amount = coinbasevalue - mn_amount outputs = {miner_address: str(Decimal(miner_amount) / COIN)} if mn_amount > 0: outputs[mn_payee] = str(Decimal(mn_amount) / COIN) coinbase = FromHex(CTransaction(), node.createrawtransaction([], outputs)) coinbase.vin = create_coinbase(height).vin # We can't really use this one as it would result in invalid merkle roots for masternode lists if len(bt['coinbase_payload']) != 0: cbtx = FromHex(CCbTx(version=1), bt['coinbase_payload']) coinbase.nVersion = 3 coinbase.nType = 5 # CbTx coinbase.vExtraPayload = cbtx.serialize() coinbase.calc_sha256() block = create_block(int(tip_hash, 16), coinbase, nTime=bt['curtime']) block.vtx += vtx # Add quorum commitments from template for tx in bt['transactions']: tx2 = FromHex(CTransaction(), tx['data']) if tx2.nType == 6: block.vtx.append(tx2) block.hashMerkleRoot = block.calc_merkle_root() block.solve() return block def create_chainlock(self, height, blockHash): request_id = "%064x" % uint256_from_str(hash256(ser_string(b"clsig") + struct.pack("<I", height))) message_hash = "%064x" % blockHash for mn in self.mninfo: mn.node.quorum('sign', 100, request_id, message_hash) recSig = None t = time() while time() - t < 10: try: recSig = self.nodes[0].quorum('getrecsig', 100, request_id, message_hash) break except: sleep(0.1) assert(recSig is not None) clsig = msg_clsig(height, blockHash, hex_str_to_bytes(recSig['sig'])) return clsig def create_islock(self, hextx): tx = FromHex(CTransaction(), hextx) tx.rehash() request_id_buf = ser_string(b"islock") + ser_compact_size(len(tx.vin)) inputs = [] for txin in tx.vin: request_id_buf += txin.prevout.serialize() inputs.append(txin.prevout) request_id = "%064x" % uint256_from_str(hash256(request_id_buf)) message_hash = "%064x" % tx.sha256 for mn in self.mninfo: mn.node.quorum('sign', 100, request_id, message_hash) recSig = None t = time() while time() - t < 10: try: recSig = self.nodes[0].quorum('getrecsig', 100, request_id, message_hash) break except: sleep(0.1) assert(recSig is not None) islock = msg_islock(inputs, tx.sha256, hex_str_to_bytes(recSig['sig'])) return islock if __name__ == '__main__': LLMQ_IS_CL_Conflicts().main()
39.00885
125
0.628176
[ "MIT" ]
cryptowithacause/cryptocause-coin
qa/rpc-tests/llmq-is-cl-conflicts.py
13,224
Python
#!/usr/bin/env python # # @file test_signals.py # # @author Matt Gigli <[email protected]> # # @section LICENSE # # The MIT License (MIT) # Copyright (c) 2016 Matt Gigli # # 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 from ao.signals import dispatcher class test_signals(unittest.TestCase): def setUp(self): self.cb1 = 0 self.cb2 = 0 self.cb3 = 0 self.cb4 = 0 self.cb5 = 0 self.cb6 = 0 self.cb_arg1 = None self.cb_arg2 = None def tearDown(self): dispatcher.unsubscribe_all() def callback_1(self): self.cb1 = 1 def callback_2(self): self.cb2 = 2 def callback_1234(self): self.cb1 = 1 self.cb2 = 2 self.cb3 = 3 self.cb4 = 4 def callback_34(self): self.cb3 = 3 self.cb4 = 4 def callback_56(self): self.cb5 = 5 self.cb6 = 6 def callback_args(self, arg1, arg2=None): self.cb_arg1 = arg1 self.cb_arg2 = arg2 def test_one_receiver(self): # verify test class members are reset self.assertEqual(self.cb1, 0) # subscribe to the cb1_sig signal dispatcher.subscribe('cb1_sig', self.callback_1) # publish the signal to call the callback dispatcher.publish('cb1_sig') # verify callback was called self.assertEqual(self.cb1, 1) def test_arguments(self): # verify test class members are reset self.assertEqual(self.cb_arg1, None) self.assertEqual(self.cb_arg2, None) # subscribe to the cbarg_sig signal dispatcher.subscribe('cbarg_sig', self.callback_args) # publish the signal to call the callback dispatcher.publish('cbarg_sig', 'arg1', arg2='arg2') # verify callback was called self.assertEqual(self.cb_arg1, 'arg1') self.assertEqual(self.cb_arg2, 'arg2') def test_multiple_receivers(self): # verify test class members are reset self.assertEqual(self.cb1, 0) self.assertEqual(self.cb2, 0) self.assertEqual(self.cb3, 0) self.assertEqual(self.cb4, 0) # subscribe to the signals dispatcher.subscribe('cb2_sig', self.callback_1234) # publish the signal to call the callbacks dispatcher.publish('cb2_sig') # verify callbacks were called self.assertEqual(self.cb1, 1) self.assertEqual(self.cb2, 2) self.assertEqual(self.cb3, 3) self.assertEqual(self.cb4, 4) def test_publish_unsubscribed_signal(self): # publish a signal that hasn't been subscribed to, to verify that no # error occurs when publishing such a signal dispatcher.publish('lonely_sig') def test_unsubscribe_unsubscribed_signal(self): # verify no exception is raised when unsubscribing a receiver from a # signal that was never subscribed to dispatcher.unsubscribe('lonely_sig', self.callback_1) def test_unsubscribe(self): # subscribe, publish and check that callback was called dispatcher.subscribe('cb1_sig', self.callback_1) dispatcher.publish('cb1_sig') self.assertEqual(self.cb1, 1) # reset cb1, unsubscribe and show that callback is not called self.cb1 = 0 dispatcher.unsubscribe('cb1_sig', self.callback_1) dispatcher.publish('cb1_sig') self.assertEqual(self.cb1, 0) def test_unsubscribe_all_for_signal(self): # subscribe some receivers for some signals dispatcher.subscribe('cb1_sig', self.callback_1) dispatcher.subscribe('cb1_sig', self.callback_2) dispatcher.subscribe('cb3_sig', self.callback_34) dispatcher.subscribe('cb3_sig', self.callback_56) # unsuscribe just for cb1_sig dispatcher.unsubscribe_all('cb1_sig') # verify only cb1_sig receivers were unsubscribed dispatcher.publish('cb1_sig') dispatcher.publish('cb3_sig') self.assertEqual(self.cb1, 0) self.assertEqual(self.cb2, 0) self.assertEqual(self.cb3, 3) self.assertEqual(self.cb4, 4) self.assertEqual(self.cb5, 5) self.assertEqual(self.cb6, 6) def test_unsubscribe_all(self): dispatcher.subscribe('cb1_sig', self.callback_1) dispatcher.subscribe('cb1_sig', self.callback_2) dispatcher.subscribe('cb3_sig', self.callback_34) dispatcher.subscribe('cb3_sig', self.callback_56) # unsuscribe all signals dispatcher.unsubscribe_all() # verify all receivers were unsubscribed dispatcher.publish('cb1_sig') dispatcher.publish('cb3_sig') self.assertEqual(self.cb1, 0) self.assertEqual(self.cb2, 0) self.assertEqual(self.cb3, 0) self.assertEqual(self.cb4, 0) self.assertEqual(self.cb5, 0) self.assertEqual(self.cb6, 0)
33.005556
79
0.666723
[ "MIT" ]
mjgigli/active-object
test/test_signals.py
5,941
Python
import asyncio import sys import click from pydantic import SecretStr from server.application.auth.commands import ChangePassword from server.config.di import bootstrap, resolve from server.domain.auth.entities import User from server.domain.auth.repositories import UserRepository from server.seedwork.application.messages import MessageBus async def _prompt_user() -> User: repository = resolve(UserRepository) email = click.prompt("Email") user = await repository.get_by_email(email) if user is None: click.echo(click.style(f"User does not exist: {email}", fg="red")) sys.exit(1) return user def _prompt_password() -> SecretStr: return click.prompt( "Password", confirmation_prompt="Password (repeat)", value_proc=SecretStr, hide_input=True, ) async def main() -> None: bus = resolve(MessageBus) user = await _prompt_user() password = _prompt_password() await bus.execute(ChangePassword(email=user.email, password=password)) if __name__ == "__main__": bootstrap() asyncio.run(main())
22.510204
74
0.710789
[ "MIT" ]
multi-coop/catalogage-donnees
tools/changepassword.py
1,103
Python
"""Various functions that interact with Slack, e.g. posting messages.""" import asyncio import logging import socket from pathlib import Path from typing import Union, Optional from slack_sdk.errors import SlackApiError from lsw_slackbot.plots import plot_resource_use from lsw_slackbot.resources import current_memory_fraction, _get_resource_usage_dataframe from lsw_slackbot.util import string_time async def _send_message(client, channel: str, message: str): """Sends a message to a channel, with basic logging & error handling.""" try: await client.chat_postMessage(channel=channel, text=message) # Handle various different errors, *some* of which are non-critical... except SlackApiError as e: logging.exception(f"error from slack API when trying to send message: {e.response['error']}") print("Encountered SlackApiError when trying to send message (see logs.)") except AttributeError: logging.exception("suspected issue in Slack API when trying to send message. This bug has occured before!") print("Encountered AttributeError when trying to send message (see logs.)") async def _send_file(client, channel: str, file: Union[Path, str], title): """Sends a file to a channel, with basic logging & error handling.""" if isinstance(file, Path): file = str(file.absolute()) try: await client.files_upload(channels=channel, file=file, title=title) # Handle various different errors, *some* of which are non-critical... except SlackApiError as e: logging.exception(f"error from Slack API when trying to upload file: {e.response['error']}") print("Encountered SlackApiError when trying to upload file (see logs.)") except AttributeError: logging.exception("suspected issue in Slack API when trying to upload file. This bug has occured before!") print("Encountered AttributeError when trying to upload file (see logs.)") async def hello_world(client, channel: str): """Basic function to post an init message to a channel.""" # Todo: it would be really cool if hello_world also printed the latest commit message. # This could be done by running the command `git log -1` from Python? # See https://stackoverflow.com/questions/7293008/display-last-git-commit-comment logging.info(f"Saying hello world in {channel}!") system_name = socket.gethostname() await _send_message( client, channel, f"Server time & date: {string_time()}\nApp is running on system {system_name}.") async def send_resource_use_plot(client, channel: str, plot_kwargs: dict, title: Optional[str] = None): """Sends a resource usage plot to a given channel.""" if title is None: title = f"Resource usage plot generated at {string_time()}" else: title = title + f" (plot generated at {string_time()})" # Firstly, let's generate a plot logging.info("Generating a resource usage plot") logging.debug(f"plot kwargs: {plot_kwargs}") location_plot = await plot_resource_use(**plot_kwargs) # Now, let's try and send it to slack logging.info(f"Sending to Slack in channel {channel}") await _send_file(client, channel, location_plot, title) _LAST_MEMORY_FRACTION = 0.0 async def check_memory(client, channel: str, memory_warn_fraction=0.8, sleep_time=3600): """Quick function for checking current server memory and sending a warning to a desired channel if it's too high.""" global _LAST_MEMORY_FRACTION # Sorry for using global variables =( current_usage = current_memory_fraction() # Only warn if we didn't warn before if _LAST_MEMORY_FRACTION < memory_warn_fraction: if current_usage > memory_warn_fraction: # Firstly, prioritise sending a basic warning await _send_message(client, channel, f"WARNING: current memory usage at {current_usage:.2%}!") # Next, grab info on currently running threads thread_df = await _get_resource_usage_dataframe(measurement_time=1.0) thread_df = thread_df.sort_values("memory") # ... and format it into something we can send message = ["Users with something currently running:"] for i, a_row in thread_df.iterrows(): message.append(f"{a_row.name}: {a_row['cpu_percent']:.2f}% CPU " f"-- {a_row['memory']:.2f} GB" f"-- {a_row['threads']} threads") message.append(f"\n(no further warnings will be sent for a sleep period of {sleep_time/60**2:.2f} hour(s))") # Send it! await _send_message(client, channel, "\n".join(message)) # Sleep so we don't spam the chat await asyncio.sleep(sleep_time) _LAST_MEMORY_FRACTION = current_usage
41.444444
120
0.690864
[ "BSD-3-Clause" ]
emilyhunt/lsw-slackbot
lsw_slackbot/slack.py
4,849
Python
from contextlib import contextmanager import platform import shlex from subprocess import PIPE, Popen from shutil import which class ShellCommandResult(tuple): """ The result of a :func:`coalib.misc.run_shell_command` call. It is based on a ``(stdout, stderr)`` string tuple like it is returned form ``subprocess.Popen.communicate`` and was originally returned from :func:`coalib.misc.run_shell_command`. So it is backwards-compatible. It additionally stores the return ``.code``: >>> process = Popen(['python', '-c', ... 'import sys; print(sys.stdin.readline().strip() +' ... ' " processed")'], ... stdin=PIPE, stdout=PIPE, stderr=PIPE, ... universal_newlines=True) >>> stdout, stderr = process.communicate(input='data') >>> stderr '' >>> result = ShellCommandResult(process.returncode, stdout, stderr) >>> result[0] 'data processed\\n' >>> result[1] '' >>> result.code 0 """ def __new__(cls, code, stdout, stderr): """ Creates the basic tuple from `stdout` and `stderr`. """ return tuple.__new__(cls, (stdout, stderr)) def __init__(self, code, stdout, stderr): """ Stores the return `code`. """ self.code = code @contextmanager def run_interactive_shell_command(command, **kwargs): """ Runs a single command in shell and provides stdout, stderr and stdin streams. This function creates a context manager that sets up the process (using ``subprocess.Popen()``), returns to caller and waits for process to exit on leaving. By default the process is opened in ``universal_newlines`` mode and creates pipes for all streams (stdout, stderr and stdin) using ``subprocess.PIPE`` special value. These pipes are closed automatically, so if you want to get the contents of the streams you should retrieve them before the context manager exits. >>> with run_interactive_shell_command(["echo", "TEXT"]) as p: ... stdout = p.stdout ... stdout_text = stdout.read() >>> stdout_text 'TEXT\\n' >>> stdout.closed True Custom streams provided are not closed except of ``subprocess.PIPE``. >>> from tempfile import TemporaryFile >>> stream = TemporaryFile() >>> with run_interactive_shell_command(["echo", "TEXT"], ... stdout=stream) as p: ... stderr = p.stderr >>> stderr.closed True >>> stream.closed False :param command: The command to run on shell. This parameter can either be a sequence of arguments that are directly passed to the process or a string. A string gets splitted beforehand using ``shlex.split()``. If providing ``shell=True`` as a keyword-argument, no ``shlex.split()`` is performed and the command string goes directly to ``subprocess.Popen()``. :param kwargs: Additional keyword arguments to pass to ``subprocess.Popen`` that are used to spawn the process. :return: A context manager yielding the process started from the command. """ if not kwargs.get('shell', False) and isinstance(command, str): command = shlex.split(command) else: command = list(command) if platform.system() == 'Windows': # pragma: no cover # subprocess doesn't implicitly look for .bat and .cmd scripts when # running commands under Windows command[0] = which(command[0]) args = {'stdout': PIPE, 'stderr': PIPE, 'stdin': PIPE, 'universal_newlines': True} args.update(kwargs) process = Popen(command, **args) try: yield process finally: if args['stdout'] is PIPE: process.stdout.close() if args['stderr'] is PIPE: process.stderr.close() if args['stdin'] is PIPE: process.stdin.close() process.wait() def run_shell_command(command, stdin=None, **kwargs): """ Runs a single command in shell and returns the read stdout and stderr data. This function waits for the process (created using ``subprocess.Popen()``) to exit. Effectively it wraps ``run_interactive_shell_command()`` and uses ``communicate()`` on the process. See also ``run_interactive_shell_command()``. :param command: The command to run on shell. This parameter can either be a sequence of arguments that are directly passed to the process or a string. A string gets splitted beforehand using ``shlex.split()``. :param stdin: Initial input to send to the process. :param kwargs: Additional keyword arguments to pass to ``subprocess.Popen`` that is used to spawn the process. :return: A tuple with ``(stdoutstring, stderrstring)``. """ with run_interactive_shell_command(command, **kwargs) as p: ret = p.communicate(stdin) return ShellCommandResult(p.returncode, *ret) def get_shell_type(): # pragma: no cover """ Finds the current shell type based on the outputs of common pre-defined variables in them. This is useful to identify which sort of escaping is required for strings. :return: The shell type. This can be either "powershell" if Windows Powershell is detected, "cmd" if command prompt is been detected or "sh" if it's neither of these. """ out = run_shell_command('echo $host.name', shell=True)[0] if out.strip() == 'ConsoleHost': return 'powershell' out = run_shell_command('echo $0', shell=True)[0] if out.strip() == '$0': return 'cmd' return 'sh'
35.42515
79
0.615619
[ "MIT" ]
prashant0598/CoffeeApp
venv/lib/python3.5/site-packages/coalib/misc/Shell.py
5,916
Python
#!/usr/bin/env python import numpy as np def initialize_hyper_parameters(layer_acts, learning_rate): """ Initialize parameters for different levels of the network Arguments: layer_acts -- python array (list) containing the activation functions of each layer in the network learning_rate -- float value used as constant for gradient descent Returns: hyper_parameters -- python dictionary containing hyper_parameters (can be further extended) """ hyper_parameters = {} activations = {} L = len(layer_acts) # number of layers in the network for l in range(0, L): activations[l+1] = layer_acts[l] hyper_parameters["activations"] = activations hyper_parameters["learning_rate"] = learning_rate return hyper_parameters def test_initialize_hyper_parameters(): print("\033[92m" + "\nTest initialize_hyper_parameters() ..." + "\033[0m") layer_acts = ["relu", "relu", "sigmoid"] learning_rate = 0.0075 hyper_parameters = initialize_hyper_parameters(layer_acts, learning_rate) print(hyper_parameters["activations"]) assert len(hyper_parameters["activations"]) == 3 assert hyper_parameters["activations"][1] == "relu" print("\033[92m" + "... end test" + "\033[0m") def initialize_parameters(layer_dims): """ Initialize parameters for different levels of the network Arguments: layer_dims -- python array (list) containing the dimensions of each layer in the network Returns: parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL", ...: Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1]) bl -- bias vector of shape (layer_dims[l], 1) """ np.random.seed(1) parameters = {} L = len(layer_dims) # number of layers in the network for l in range(1, L): parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * 0.01 parameters['b' + str(l)] = np.zeros((layer_dims[l], 1)) assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l-1])) assert(parameters['b' + str(l)].shape == (layer_dims[l], 1)) return parameters def test_initialize_parameters(): print("\n" + "\033[92m" + "Test initialize_parameters() ..." + "\033[0m") np.random.seed(1) parameters = initialize_parameters([3,2,1]) print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"])) W1 = parameters["W1"] W1_expected = np.array([[0.01624345,-0.00611756,-0.00528172],[-0.01072969,0.00865408,-0.02301539]]) assert np.allclose(W1, W1_expected, rtol=1e-05, atol=1e-06) b1 = parameters["b1"] b1_expected = np.array([[0.],[0.]]) assert np.allclose(b1, b1_expected, rtol=1e-05, atol=1e-06) W2 = parameters["W2"] W2_expected = np.array([[0.01744812, -0.00761207]]) assert np.allclose(W2, W2_expected, rtol=1e-05, atol=1e-06) b2 = parameters["b2"] b2_expected = np.array([[ 0.]]) assert np.allclose(b2, b2_expected, rtol=1e-05, atol=1e-06) print("\033[92m" + "... end test" + "\033[0m") if __name__ == "__main__": test_initialize_hyper_parameters() test_initialize_parameters()
32.861386
103
0.647484
[ "Apache-2.0" ]
giuseppefutia/word2vec
utils/init_parameters.py
3,319
Python
""" Code for particle tracking, designed for ROMS output. This new version makes extensive use of nearest-neighbor KDTree algorithms for interpolation. This results is significantly (36x) faster runtimes compared with old version. PERFORMANCE: about 3 minutes per day for a 3D cas6 experiment with 10k particles. NOTE: You have to have run make_KDTrees.py for the grid (e.g. cas6) before running. NOTE: There is some issue, perhaps with garbage collection, which causes the loading of NetCDF files to happen slower after running a few times interactively from ipython. It appears that this can be avoided by running from the terminal as: python tracker.py [args]. This program is a driver where you specify: - an experiment (ROMS run + release locations + other choices) - a release or set of releases within that experiment (start day, etc.) The main argument you provide is -exp, which is the experiment name, and is used by experiments.get_exp_info() and .get_ic() to get the gtagex and initial particle locations. Other possible commmand line arguments and their defaults are explained in the argparse section below. NOTE: To improve usefulness for people other than me, this driver will first look for: - LiveOcean_user/tracker/user_trackfun.py before loading my versions. This allows you to create your own modifications to the tracking (e.g. for diurnal depth behavior) while still being able to use git pull to update the main code. It can be run on its own, or with command line arguments to facilitate large, automated jobs, for example in python: Examples: python tracker.py -clb True the same command, with all the argmuents typed, instead of getting the as defaults: python tracker.py -gtx cas6_v3_lo8b -ro 2 -d 2019.07.04 -exp jdf0 -clb True """ import sys from datetime import datetime, timedelta from time import time import argparse import numpy as np from lo_tools import Lfun, zfun Ldir = Lfun.Lstart() from importlib import reload pth = Ldir['LOu'] / 'tracker' if str(pth) not in sys.path: sys.path.append(str(pth)) import experiments as exp reload(exp) import trackfun_nc as tfnc reload(tfnc) # The import of trackfun or user_trackfun is done later in this program, # about 100 lines down. # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # command line arguments, can be input in any order parser = argparse.ArgumentParser() # Set the experiment name # (details set in experiments.py, or, if it exists, user_experiments.py) parser.add_argument('-gtx', '--gtagex', default='cas6_v0_live', type=str) parser.add_argument('-ro', '--roms_out_num', default=2, type=int) # 1 = Ldir['roms_out1'], etc. # this is the first starting day parser.add_argument('-d', '--date_string', default='2021.10.15', type=str) parser.add_argument('-exp', '--exp_name', default='elb', type=str) parser.add_argument('-clb', '--clobber', default=False, type=zfun.boolean_string) # overwrite existing output folder if clobber == True parser.add_argument('-sub_tag', default='', type=str) # append an optional tag to the end of the output folder name # These are False unless the flags are used with the argument True # so if you do NOT use these flags the run will be: # - trapped to the surface # - no vertical turbulent diffusion parser.add_argument('-3d', default=False, type=zfun.boolean_string) # do 3d tracking parser.add_argument('-laminar', default=False, type=zfun.boolean_string) # no turbulence parser.add_argument('-no_advection', default=False, type=zfun.boolean_string) # no advection parser.add_argument('-sink', default=0, type=float) # particle sinking speed (m per day, e.g. 40) # windage = a small number: 0 <= windage << 1 (e.g. 0.03) # fraction of windspeed added to advection, only for 3d=False parser.add_argument('-wnd', '--windage', default=0, type=float) # You can make multiple releases using: # number_of_start_days > 1 & days_between_starts, and which hour (UTC) to start on parser.add_argument('-nsd', '--number_of_start_days', default=1, type=int) parser.add_argument('-dbs', '--days_between_starts', default=1, type=int) parser.add_argument('-dtt', '--days_to_track', default=1, type=int) parser.add_argument('-sh', '--start_hour', default=0, type=int) # number of divisions to make between saves for the integration # e.g. if ndiv = 12 and we have hourly saves, we use a 300 sec step # for the integration. 300 s seems like a good default value, # based on Banas et al. (2009, CSR RISE paper). parser.add_argument('-ndiv', default=12, type=int) parser.add_argument('-sph', default=1, type=int) # sph = saves per hour, a new argument to allow more frequent writing of output. args = parser.parse_args() TR = args.__dict__ # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # set where to look for model output if args.roms_out_num == 0: TR['roms_out'] = Ldir['roms_out'] elif args.roms_out_num > 0: TR['roms_out'] = Ldir['roms_out' + str(args.roms_out_num)] # set dependent and default fields TR['turb'] = False # make sure sph is no greater than ndiv TR['sph'] = np.min((TR['sph'],TR['ndiv'])) # overrides if TR['3d']: TR['windage'] = 0 TR['turb'] = True # default is that 3d is always turbulent if TR['laminar']: TR['turb'] = False # get experiment info TR['gridname'], TR['tag'], TR['ex_name'] = TR['gtagex'].split('_') # pass some info to Ldir Ldir['gtagex'] = TR['gtagex'] Ldir['roms_out'] = TR['roms_out'] # get the full path to a valid history file fn00 = Ldir['roms_out'] / TR['gtagex'] / ('f' + TR['date_string']) / 'ocean_his_0001.nc' TR['fn00'] = fn00 # set the name of the output folder out_name = TR['exp_name'] # modify the output folder name, based on other choices if TR['3d']: out_name += '_3d' elif not TR['3d']: out_name += '_surf' if TR['laminar']: out_name += '_laminar' if TR['windage'] > 0: out_name += '_wind' + str(int(100*TR['windage'])) if TR['start_hour'] > 0: out_name += '_sh' + str(int(TR['start_hour'])) if TR['sink'] > 0: out_name += '_sink' + str(int(TR['sink'])) if TR['no_advection'] == True: out_name += '_nadv' if TR['ndiv'] != 12: # only mention ndiv if it is NOT 12 out_name += '_ndiv' + str(TR['ndiv']) if len(TR['sub_tag']) > 0: out_name += '_' + TR['sub_tag'] # make the list of start days (datetimes) for separate releases idt_list = [] dt = datetime.strptime(TR['date_string'], '%Y.%m.%d') for nic in range(TR['number_of_start_days']): idt_list.append(dt) dt = dt + timedelta(TR['days_between_starts']) # make the output directory (empty) outdir0 = Ldir['LOo'] / 'tracks' outdir1 = out_name outdir = outdir0 / outdir1 if outdir.is_dir(): if args.clobber: pass # continue and overwrite if clobber is True else: print('Warning: output directory exists - rename if you want to keep it!!') print('-- tracker run not started --') sys.exit() Lfun.make_dir(outdir, clean=True) print(50*'*' + '\nWriting to ' + str(outdir)) sys.stdout.flush() # Write some info to outdir0 for use by trackfun.py Lfun.dict_to_csv(TR, outdir0 / 'exp_info.csv') # and write the same info to outdir as part of the archived run output Lfun.dict_to_csv(TR, outdir / 'exp_info.csv') # Load the trackfun module. # NOTE: we have to load this module AFTER we write [outdir0]/exp_info.csv # because it uses that information to decide which KDTrees to load. Crude. if (Ldir['LOu'] / 'tracker' / 'user_trackfun.py').is_file(): sys.path.append(str(Ldir['LOu'] / 'tracker')) import user_trackfun as tfun else: import trackfun as tfun reload(tfun) # get the initial particle location vectors EI = exp.get_exp_info(TR['exp_name']) plon00, plat00, pcs00 = exp.get_ic(EI, TR['fn00']) # step through the releases, one for each start day write_grid = True for idt0 in idt_list: tt0 = time() # monitor integration time # name the release file by start day idt0_str = datetime.strftime(idt0,'%Y.%m.%d') outname = ('release_' + idt0_str + '.nc') print('-- ' + outname) sys.stdout.flush() out_fn = outdir / outname # we do the calculation in one-day segments, but write complete # output for a release to a single NetCDF file. for nd in range(TR['days_to_track']): # get or replace the history file list for this day idt = idt0 + timedelta(days=nd) idt_str = datetime.strftime(idt,'%Y.%m.%d') print(' - working on ' + idt_str) sys.stdout.flush() fn_list = tfun.get_fn_list(idt, Ldir) # write the grid file (once per experiment) for plotting if write_grid == True: g_infile = fn_list[0] g_outfile = outdir / 'grid.nc' tfnc.write_grid(g_infile, g_outfile) write_grid = False # DO THE TRACKING if nd == 0: # first day # set IC plon0 = plon00.copy() plat0 = plat00.copy() pcs0 = pcs00.copy() # do the tracking if TR['start_hour'] > 0: fn_list = fn_list[TR['start_hour']:] P = tfun.get_tracks(fn_list, plon0, plat0, pcs0, TR, trim_loc=True) # save the results to NetCDF tfnc.start_outfile(out_fn, P) else: # subsequent days # set IC plon0 = P['lon'][-1,:] plat0 = P['lat'][-1,:] pcs0 = P['cs'][-1,:] # do the tracking P = tfun.get_tracks(fn_list, plon0, plat0, pcs0, TR) tfnc.append_to_outfile(out_fn, P) print(' - Took %0.1f sec for %s day(s)' % (time() - tt0, str(TR['days_to_track']))) print(50*'=') print(50*'*' + '\nWrote to ' + str(outdir))
35.465201
97
0.673001
[ "MIT" ]
PuffyPuffin/LO_user
tracker/tracker/user_tracker.py
9,682
Python
""" Custom Decorators """ # Django from django.shortcuts import redirect, reverse from django.http import JsonResponse from django.utils.translation import gettext as _ from django.http import Http404 # local Django from app.modules.util.helpers import Helpers from app.modules.core.response import Response from app.modules.entity.option_entity import Option_Entity def redirect_if_authenticated(function): def wrap(controller, request, *args, **kwargs): if request.user and request.user.is_authenticated: if "redirect" in request.GET: return redirect(request.GET["redirect"]) return redirect("app.web.admin.dashboard") return function(controller, request, *args, **kwargs) return wrap def login_if_not_authenticated(function): def wrap(controller, request, *args, **kwargs): if not request.user or not request.user.is_authenticated: return redirect(reverse("app.web.login") + "?redirect=" + request.get_full_path()) return function(controller, request, *args, **kwargs) return wrap def stop_request_if_authenticated(function): def wrap(controller, request, *args, **kwargs): if request.user and request.user.is_authenticated: response = Response() return JsonResponse(response.send_private_failure([{ "type": "error", "message": _("Error! Access forbidden for authenticated users.") }])) return function(controller, request, *args, **kwargs) return wrap def redirect_if_not_installed(function): def wrap(controller, request, *args, **kwargs): installed = False if Option_Entity().get_one_by_key("app_installed") is False else True if not installed: return redirect("app.web.install") return function(controller, request, *args, **kwargs) return wrap def protect_metric_with_auth_key(function): def wrap(controller, request, *args, **kwargs): if kwargs["type"] == "prometheus": prometheus_token = Option_Entity().get_one_by_key("prometheus_token") if prometheus_token.value != "" and ("HTTP_AUTHORIZATION" not in request.META or prometheus_token.value != request.META["HTTP_AUTHORIZATION"]): raise Http404("Host not found.") return function(controller, request, *args, **kwargs) return wrap def stop_request_if_installed(function): def wrap(controller, request, *args, **kwargs): installed = False if Option_Entity().get_one_by_key("app_installed") is False else True if installed: response = Response() return JsonResponse(response.send_private_failure([{ "type": "error", "message": _("Error! Application is already installed.") }])) return function(controller, request, *args, **kwargs) return wrap def log_request_data(function): def wrap(controller, request, *args, **kwargs): _helper = Helpers() _logger = _helper.get_logger(__name__) _logger.debug(_("Request Method: %s") % request.method) _logger.debug(_("Request URL: %s") % request.path) _logger.debug(_("Request Body: %s") % request.body) return function(controller, request, *args, **kwargs) return wrap
37.943182
155
0.668763
[ "Apache-2.0" ]
Clivern/Kraven
app/modules/core/decorators.py
3,339
Python
from datetime import datetime, timedelta from django.test import TestCase from mock import patch from corehq.apps.domain.models import Domain from corehq.apps.hqcase.utils import update_case from corehq.apps.sms.mixin import PhoneNumberInUseException from corehq.apps.sms.models import ( PhoneNumber, SQLMobileBackend, SQLMobileBackendMapping, ) from corehq.apps.sms.tasks import ( delete_phone_numbers_for_owners, sync_case_phone_number, ) from corehq.apps.sms.tests.util import delete_domain_phone_numbers from corehq.apps.users.models import CommCareUser, WebUser from corehq.apps.users.tasks import tag_cases_as_deleted_and_remove_indices from corehq.form_processor.interfaces.dbaccessors import CaseAccessors from corehq.form_processor.tests.utils import run_with_all_backends from corehq.form_processor.utils import is_commcarecase from corehq.messaging.smsbackends.test.models import SQLTestSMSBackend from corehq.util.test_utils import create_test_case class PhoneNumberCacheClearTestCase(TestCase): def assertNoMatch(self, phone_search, suffix_search, owner_id_search): self.assertIsNone(PhoneNumber.get_two_way_number(phone_search)) self.assertIsNone(PhoneNumber.get_two_way_number_by_suffix(suffix_search)) self.assertEqual(PhoneNumber.by_owner_id(owner_id_search), []) def assertPhoneNumbersEqual(self, phone1, phone2): for field in phone1._meta.fields: self.assertEqual(getattr(phone1, field.name), getattr(phone2, field.name)) def assertMatch(self, match, phone_search, suffix_search, owner_id_search): lookedup = PhoneNumber.get_two_way_number(phone_search) self.assertPhoneNumbersEqual(match, lookedup) lookedup = PhoneNumber.get_two_way_number_by_suffix(suffix_search) self.assertPhoneNumbersEqual(match, lookedup) [lookedup] = PhoneNumber.by_owner_id(owner_id_search) self.assertPhoneNumbersEqual(match, lookedup) def _test_cache_clear(self, refresh_each_time=True): """ A test to make sure that the cache clearing is working as expected. This test gets run twice using different values for refresh_each_time. This makes sure that the mechanism used for clearing the cache works whether you're updating a document you just saved or getting a document fresh from the database and updating it. """ created = PhoneNumber( domain='phone-number-test', owner_doc_type='CommCareCase', owner_id='fake-owner-id1', phone_number='99912341234', backend_id=None, ivr_backend_id=None, verified=True, pending_verification=False, is_two_way=True, contact_last_modified=datetime.utcnow() ) created.save() self.assertNoMatch('99952345234', '52345234', 'fake-owner-id2') self.assertMatch(created, '99912341234', '12341234', 'fake-owner-id1') # Update Phone Number if refresh_each_time: created = PhoneNumber.objects.get(pk=created.pk) created.phone_number = '99952345234' created.save() self.assertNoMatch('99912341234', '12341234', 'fake-owner-id2') self.assertMatch(created, '99952345234', '52345234', 'fake-owner-id1') # Update Owner Id if refresh_each_time: created = PhoneNumber.objects.get(pk=created.pk) created.owner_id = 'fake-owner-id2' created.save() self.assertNoMatch('99912341234', '12341234', 'fake-owner-id1') self.assertMatch(created, '99952345234', '52345234', 'fake-owner-id2') created.delete() self.assertNoMatch('99952345234', '52345234', 'fake-owner-id2') def test_cache_clear_with_refresh(self): self._test_cache_clear(refresh_each_time=True) def test_cache_clear_without_refresh(self): self._test_cache_clear(refresh_each_time=False) class CaseContactPhoneNumberTestCase(TestCase): def setUp(self): self.domain = 'case-phone-number-test' def tearDown(self): delete_domain_phone_numbers(self.domain) def set_case_property(self, case, property_name, value): update_case(self.domain, case.case_id, case_properties={property_name: value}) return CaseAccessors(self.domain).get_case(case.case_id) def get_case_phone_number(self, case): return case.get_phone_number() def assertPhoneNumberDetails(self, case, phone_number, sms_backend_id, ivr_backend_id, verified, pending_verification, is_two_way, pk=None): v = self.get_case_phone_number(case) self.assertEqual(v.domain, case.domain) self.assertEqual(v.owner_doc_type, case.doc_type) self.assertEqual(v.owner_id, case.case_id) self.assertEqual(v.phone_number, phone_number) self.assertEqual(v.backend_id, sms_backend_id) self.assertEqual(v.ivr_backend_id, ivr_backend_id) self.assertEqual(v.verified, verified) self.assertEqual(v.pending_verification, pending_verification) self.assertEqual(v.is_two_way, is_two_way) self.assertEqual(v.contact_last_modified, case.server_modified_on) if pk: self.assertEqual(v.pk, pk) @run_with_all_backends def test_case_phone_number_updates(self): extra_number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case: self.assertIsNone(self.get_case_phone_number(case)) case = self.set_case_property(case, 'contact_phone_number', '99987658765') self.assertPhoneNumberDetails(case, '99987658765', None, None, False, False, False) pk = self.get_case_phone_number(case).pk self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) case = self.set_case_property(case, 'contact_phone_number_is_verified', '1') self.assertPhoneNumberDetails(case, '99987658765', None, None, True, False, True, pk=pk) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) case = self.set_case_property(case, 'contact_phone_number', '99987698769') self.assertPhoneNumberDetails(case, '99987698769', None, None, True, False, True) pk = self.get_case_phone_number(case).pk self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) case = self.set_case_property(case, 'contact_backend_id', 'sms-backend') self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', None, True, False, True, pk=pk) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) case = self.set_case_property(case, 'contact_ivr_backend_id', 'ivr-backend') self.assertPhoneNumberDetails(case, '99987698769', 'sms-backend', 'ivr-backend', True, False, True, pk=pk) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) # If phone entry is ahead of the case in terms of contact_last_modified, no update should happen v = self.get_case_phone_number(case) v.contact_last_modified += timedelta(days=1) v.save() with patch('corehq.apps.sms.models.PhoneNumber.save') as mock_save: case = self.set_case_property(case, 'contact_phone_number', '99912341234') self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) mock_save.assert_not_called() self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number) @run_with_all_backends def test_close_case(self): extra_number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case: case = self.set_case_property(case, 'contact_phone_number', '99987658765') case = self.set_case_property(case, 'contact_phone_number_is_verified', '1') self.assertIsNotNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) update_case(self.domain, case.case_id, close=True) self.assertIsNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number) @run_with_all_backends def test_case_soft_delete(self): extra_number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case: case = self.set_case_property(case, 'contact_phone_number', '99987658765') case = self.set_case_property(case, 'contact_phone_number_is_verified', '1') self.assertIsNotNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) tag_cases_as_deleted_and_remove_indices(self.domain, [case.case_id], '123', datetime.utcnow()) self.assertIsNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number) @run_with_all_backends def test_case_zero_phone_number(self): extra_number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case: case = self.set_case_property(case, 'contact_phone_number', '99987658765') case = self.set_case_property(case, 'contact_phone_number_is_verified', '1') self.assertIsNotNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) case = self.set_case_property(case, 'contact_phone_number', '0') self.assertIsNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number) @run_with_all_backends def test_invalid_phone_format(self): extra_number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case: case = self.set_case_property(case, 'contact_phone_number', '99987658765') case = self.set_case_property(case, 'contact_phone_number_is_verified', '1') self.assertIsNotNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) case = self.set_case_property(case, 'contact_phone_number', 'xyz') self.assertIsNone(self.get_case_phone_number(case)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number) @run_with_all_backends def test_phone_number_already_in_use(self): self.assertEqual(PhoneNumber.count_by_domain(self.domain), 0) with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case1, \ create_test_case(self.domain, 'participant', 'test2', drop_signals=False) as case2: case1 = self.set_case_property(case1, 'contact_phone_number', '99987658765') case1 = self.set_case_property(case1, 'contact_phone_number_is_verified', '1') case2 = self.set_case_property(case2, 'contact_phone_number', '99987698769') case2 = self.set_case_property(case2, 'contact_phone_number_is_verified', '1') self.assertIsNotNone(self.get_case_phone_number(case1)) self.assertIsNotNone(self.get_case_phone_number(case2)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) case2 = self.set_case_property(case2, 'contact_phone_number', '99987658765') self.assertIsNotNone(self.get_case_phone_number(case1)) self.assertIsNotNone(self.get_case_phone_number(case2)) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) self.assertPhoneNumberDetails(case1, '99987658765', None, None, True, False, True) self.assertPhoneNumberDetails(case2, '99987658765', None, None, False, False, False) @run_with_all_backends def test_multiple_entries(self): extra_number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999124', verified=False, pending_verification=False, is_two_way=False ) with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case: case = self.set_case_property(case, 'contact_phone_number', '999124') case = self.set_case_property(case, 'contact_phone_number_is_verified', '1') case.create_phone_entry('999125') self.assertEqual(PhoneNumber.objects.count(), 3) sync_case_phone_number(case) self.assertEqual(PhoneNumber.objects.count(), 2) number1 = PhoneNumber.objects.get(pk=extra_number.pk) self.assertEqual(number1.owner_id, 'X') number2 = PhoneNumber.objects.get(owner_id=case.case_id) self.assertTrue(number2.verified) self.assertTrue(number2.is_two_way) self.assertFalse(number2.pending_verification) class SQLPhoneNumberTestCase(TestCase): def setUp(self): self.domain = 'sql-phone-number-test' self.domain_obj = Domain(name=self.domain) self.domain_obj.save() def delete_objects(self, result): for obj in result: # Delete and clear cache obj.delete() def tearDown(self): self.delete_objects(PhoneNumber.objects.filter(domain=self.domain)) self.delete_objects(SQLMobileBackend.objects.filter(domain=self.domain)) SQLMobileBackendMapping.objects.filter(domain=self.domain).delete() self.domain_obj.delete() def test_backend(self): backend1 = SQLTestSMSBackend.objects.create( hq_api_id=SQLTestSMSBackend.get_api_id(), is_global=False, domain=self.domain, name='BACKEND1' ) backend2 = SQLTestSMSBackend.objects.create( hq_api_id=SQLTestSMSBackend.get_api_id(), is_global=False, domain=self.domain, name='BACKEND2' ) SQLMobileBackendMapping.set_default_domain_backend(self.domain, backend1) number = PhoneNumber(domain=self.domain, phone_number='+999123') self.assertEqual(number.backend, backend1) number.backend_id = backend2.name self.assertEqual(number.backend, backend2) number.backend_id = ' ' self.assertEqual(number.backend, backend1) @run_with_all_backends def test_case_owner(self): with create_test_case(self.domain, 'participant', 'test') as case: number = PhoneNumber(owner_doc_type='CommCareCase', owner_id=case.case_id) owner = number.owner self.assertTrue(is_commcarecase(owner)) self.assertEqual(owner.case_id, case.case_id) def test_user_owner(self): mobile_user = CommCareUser.create(self.domain, 'abc', 'def', None, None) number = PhoneNumber(owner_doc_type='CommCareUser', owner_id=mobile_user.get_id) owner = number.owner self.assertTrue(isinstance(owner, CommCareUser)) self.assertEqual(owner.get_id, mobile_user.get_id) web_user = WebUser.create(self.domain, 'ghi', 'jkl', None, None) number = PhoneNumber(owner_doc_type='WebUser', owner_id=web_user.get_id) owner = number.owner self.assertTrue(isinstance(owner, WebUser)) self.assertEqual(owner.get_id, web_user.get_id) number = PhoneNumber(owner_doc_type='X') self.assertIsNone(number.owner) def test_get_two_way_number(self): number1 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=False, pending_verification=False, is_two_way=False ) self.assertEqual(PhoneNumber.get_two_way_number('999123'), number1) self.assertEqual(PhoneNumber.get_two_way_number('+999 123'), number1) self.assertIsNone(PhoneNumber.get_two_way_number('999124')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999123')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999124')) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) # test cache clear on save number1.phone_number = '999124' number1.save() self.assertIsNone(PhoneNumber.get_two_way_number('999123')) self.assertEqual(PhoneNumber.get_two_way_number('999124'), number1) self.assertIsNone(PhoneNumber.get_number_pending_verification('999123')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999124')) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) # test cache clear on delete number1.delete() self.assertIsNone(PhoneNumber.get_two_way_number('999123')) self.assertIsNone(PhoneNumber.get_two_way_number('999124')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999123')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999124')) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) def test_get_number_pending_verification(self): number1 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=False, pending_verification=True, is_two_way=False ) PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=False, pending_verification=False, is_two_way=False ) self.assertIsNone(PhoneNumber.get_two_way_number('999123')) self.assertIsNone(PhoneNumber.get_two_way_number('999124')) self.assertEqual(PhoneNumber.get_number_pending_verification('999123'), number1) self.assertEqual(PhoneNumber.get_number_pending_verification('+999 123'), number1) self.assertIsNone(PhoneNumber.get_number_pending_verification('999124')) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) # test cache clear on save number1.phone_number = '999124' number1.save() self.assertIsNone(PhoneNumber.get_two_way_number('999123')) self.assertIsNone(PhoneNumber.get_two_way_number('999124')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999123')) self.assertEqual(PhoneNumber.get_number_pending_verification('999124'), number1) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) # test promotion to two-way number1.set_two_way() number1.set_verified() number1.save() self.assertIsNone(PhoneNumber.get_two_way_number('999123')) self.assertEqual(PhoneNumber.get_two_way_number('999124'), number1) self.assertIsNone(PhoneNumber.get_number_pending_verification('999123')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999124')) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) # test cache clear on delete number1.delete() self.assertIsNone(PhoneNumber.get_two_way_number('999123')) self.assertIsNone(PhoneNumber.get_two_way_number('999124')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999123')) self.assertIsNone(PhoneNumber.get_number_pending_verification('999124')) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) def test_suffix_lookup(self): number1 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) number2 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999223', verified=True, pending_verification=False, is_two_way=True ) self.assertEqual(PhoneNumber.get_two_way_number_by_suffix('1 23'), number1) self.assertEqual(PhoneNumber.get_two_way_number_by_suffix('2 23'), number2) self.assertIsNone(PhoneNumber.get_two_way_number_by_suffix('23')) # test update number1.phone_number = '999124' number1.save() number2.phone_number = '999224' number2.save() self.assertIsNone(PhoneNumber.get_two_way_number_by_suffix('1 23')) self.assertIsNone(PhoneNumber.get_two_way_number_by_suffix('2 23')) self.assertEqual(PhoneNumber.get_two_way_number_by_suffix('124'), number1) self.assertEqual(PhoneNumber.get_two_way_number_by_suffix('224'), number2) def test_extensive_search(self): number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) self.assertEqual(PhoneNumber.by_extensive_search('999123'), number) self.assertEqual(PhoneNumber.by_extensive_search('0999123'), number) self.assertEqual(PhoneNumber.by_extensive_search('00999123'), number) self.assertEqual(PhoneNumber.by_extensive_search('000999123'), number) self.assertEqual(PhoneNumber.by_extensive_search('123'), number) self.assertIsNone(PhoneNumber.by_extensive_search('999124')) def test_by_domain(self): number1 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) number2 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999124', verified=False, pending_verification=False, is_two_way=False ) number3 = PhoneNumber.objects.create( domain=self.domain + 'X', owner_doc_type='X', owner_id='X', phone_number='999124', verified=True, pending_verification=False, is_two_way=True ) self.addCleanup(number3.delete) self.assertEqual( set(PhoneNumber.by_domain(self.domain)), set([number1, number2]) ) self.assertEqual( set(PhoneNumber.by_domain(self.domain, ids_only=True)), set([number1.couch_id, number2.couch_id]) ) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2) def test_by_owner_id(self): number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='owner1', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) [lookup] = PhoneNumber.by_owner_id('owner1') self.assertEqual(lookup, number) # test cache clear number.owner_id = 'owner2' number.save() self.assertEqual(PhoneNumber.by_owner_id('owner1'), []) [lookup] = PhoneNumber.by_owner_id('owner2') self.assertEqual(lookup, number) number.verified = False number.is_two_way = False number.save() [lookup] = PhoneNumber.by_owner_id('owner2') self.assertFalse(lookup.verified) self.assertFalse(lookup.is_two_way) def create_case_contact(self, phone_number): return create_test_case( self.domain, 'participant', 'test', case_properties={ 'contact_phone_number': phone_number, 'contact_phone_number_is_verified': '1', }, drop_signals=False ) @run_with_all_backends def test_delete_phone_numbers_for_owners(self): with self.create_case_contact('9990001') as case1, \ self.create_case_contact('9990002') as case2, \ self.create_case_contact('9990003') as case3: self.assertEqual(len(PhoneNumber.by_owner_id(case1.case_id)), 1) self.assertEqual(len(PhoneNumber.by_owner_id(case2.case_id)), 1) self.assertEqual(len(PhoneNumber.by_owner_id(case3.case_id)), 1) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 3) delete_phone_numbers_for_owners([case2.case_id, case3.case_id]) self.assertEqual(len(PhoneNumber.by_owner_id(case1.case_id)), 1) self.assertEqual(len(PhoneNumber.by_owner_id(case2.case_id)), 0) self.assertEqual(len(PhoneNumber.by_owner_id(case3.case_id)), 0) self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1) def test_verify_uniqueness(self): number1 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) number2 = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='X', phone_number='999123', verified=False, pending_verification=False, is_two_way=False ) # Raises no exception number1.verify_uniqueness() # Raises PhoneNumberInUseException with self.assertRaises(PhoneNumberInUseException): number2.verify_uniqueness() class TestUserPhoneNumberSync(TestCase): def setUp(self): self.domain = 'user-phone-number-test' self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.mobile_worker1 = CommCareUser.create(self.domain, 'mobile1', 'mobile1', None, None) self.mobile_worker2 = CommCareUser.create(self.domain, 'mobile2', 'mobile2', None, None) def tearDown(self): delete_domain_phone_numbers(self.domain) self.domain_obj.delete() def assertPhoneEntries(self, user, phone_numbers): entries = user.get_phone_entries() self.assertEqual(len(entries), len(phone_numbers)) self.assertEqual(set(entries.keys()), set(phone_numbers)) def testSync(self): extra_number = PhoneNumber.objects.create( domain=self.domain, owner_doc_type='X', owner_id='owner1', phone_number='999123', verified=True, pending_verification=False, is_two_way=True ) user = self.mobile_worker1 self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 1) user.phone_numbers = ['9990001'] user.save() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 2) self.assertPhoneEntries(user, ['9990001']) before = user.get_phone_entries()['9990001'] user.phone_numbers = ['9990001', '9990002'] user.save() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 3) self.assertPhoneEntries(user, ['9990001', '9990002']) after = user.get_phone_entries()['9990001'] self.assertEqual(before.pk, after.pk) user.phone_numbers = ['9990002'] user.save() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 2) self.assertPhoneEntries(user, ['9990002']) self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number) def testRetire(self): self.mobile_worker1.phone_numbers = ['9990001'] self.mobile_worker1.save() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 1) self.assertPhoneEntries(self.mobile_worker1, ['9990001']) self.mobile_worker2.phone_numbers = ['9990002'] self.mobile_worker2.save() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 2) self.assertPhoneEntries(self.mobile_worker2, ['9990002']) self.mobile_worker1.retire(deleted_by=None) self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 1) self.assertPhoneEntries(self.mobile_worker2, ['9990002']) class TestGenericContactMethods(TestCase): def setUp(self): self.domain = 'contact-phone-number-test' self.domain_obj = Domain(name=self.domain) self.domain_obj.save() self.mobile_worker1 = CommCareUser.create(self.domain, 'mobile1', 'mobile1', None, None) self.mobile_worker2 = CommCareUser.create(self.domain, 'mobile2', 'mobile2', None, None) def tearDown(self): delete_domain_phone_numbers(self.domain) self.domain_obj.delete() def testGetOrCreate(self): before = self.mobile_worker1.get_or_create_phone_entry('999123') self.assertEqual(before.owner_doc_type, 'CommCareUser') self.assertEqual(before.owner_id, self.mobile_worker1.get_id) self.assertEqual(before.phone_number, '999123') self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 1) after = self.mobile_worker1.get_or_create_phone_entry('999123') self.assertEqual(before.pk, after.pk) self.assertEqual(after.owner_doc_type, 'CommCareUser') self.assertEqual(after.owner_id, self.mobile_worker1.get_id) self.assertEqual(after.phone_number, '999123') self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 1) def testGetPhoneEntries(self): number1 = self.mobile_worker1.get_or_create_phone_entry('999123') number2 = self.mobile_worker1.get_or_create_phone_entry('999124') self.mobile_worker1.get_or_create_phone_entry('999125') number4 = self.mobile_worker2.get_or_create_phone_entry('999126') number1.set_two_way() number2.set_pending_verification() number4.set_two_way() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 4) entries = self.mobile_worker1.get_phone_entries() self.assertEqual(set(entries.keys()), set(['999123', '999124', '999125'])) entries = self.mobile_worker1.get_two_way_numbers() self.assertEqual(set(entries.keys()), set(['999123'])) def testDelete(self): self.mobile_worker1.get_or_create_phone_entry('999123') self.mobile_worker1.get_or_create_phone_entry('999124') self.mobile_worker1.get_or_create_phone_entry('999125') self.mobile_worker2.get_or_create_phone_entry('999126') self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 4) self.mobile_worker1.delete_phone_entry('999124') self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 3) entries = self.mobile_worker1.get_phone_entries() self.assertEqual(set(entries.keys()), set(['999123', '999125'])) entries = self.mobile_worker2.get_phone_entries() self.assertEqual(set(entries.keys()), set(['999126'])) def testUserSyncNoChange(self): before = self.mobile_worker1.get_or_create_phone_entry('999123') before.set_two_way() before.set_verified() before.save() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 1) self.mobile_worker1.phone_numbers = ['999123'] self.mobile_worker1.save() self.assertEqual(PhoneNumber.by_domain(self.domain).count(), 1) after = self.mobile_worker1.get_phone_entries()['999123'] self.assertEqual(before.pk, after.pk) self.assertTrue(after.is_two_way) self.assertTrue(after.verified) self.assertFalse(after.pending_verification)
41.17485
111
0.666647
[ "BSD-3-Clause" ]
AliRizvi1/commcare-hq
corehq/apps/sms/tests/test_phone_numbers.py
34,381
Python
from hash_map_base_class import * class ProbeHashMap(HashMapBase): """Hash map implemented with linear probing for collision resolution.""" _AVAIL = object() # sentinal marks locations of previous deletions def _is_available(self,j): """Return True if the index j is available in the table.""" return self._table[j] is None or self._table[j] is ProbeHashMap._AVAIL def _find_slot(self,j,k): """Search for key k in bucket at index j. Return (success, index) tuple, described as follows: If match was found, success is True and index denotes its location. If no match found, success is False and index denotes first available slot. """ firstAvail = None while True: if self._is_available(j): if firstAvail is None: firstAvail = j # mark this as first avail if self._table[j] is None: return (False, firstAvail) # search has failed elif k == self._table[j]._key: return (True,j) # found a match j = (j+1)%len(self._table) # keep looking (cyclically) def _bucket_getitem(self,j,k): found,s = self._find_slot(j,k) if not found: raise KeyError("Key Error: " + repr(k)) # no match found return self._table[s]._value def _bucket_setitem(self,j,k,v): found,s = self._find_slot(j,k) if not found: self._table[s] = self._Item(k,v) # insert new item self._n += 1 # size has increased else: self._table[s]._value = v # overwrite existing def _bucket_delitem(self,j,k): found,s = self._find_slot(j,k) if not found: raise KeyError("Key Error: " + repr(k)) # no match found self._table[s] = ProbeHashMap._AVAIL # mark as vacated def __iter__(self): for j in range(len(self._table)): # scan entire table if not self._is_available(j): yield self._table[j]._key
40.481481
83
0.558097
[ "MIT" ]
ahammadshawki8/DSA-Implementations-in-Python
CHAPTER 10 (maps, hash tables and skip lists)/probe_hash_map_class.py
2,186
Python
# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('filer', '0009_auto_20171220_1635'), ] operations = [ migrations.AlterField( model_name='image', name='file_ptr', field=models.OneToOneField(primary_key=True, serialize=False, related_name='filer_image_file', parent_link=True, to='filer.File', on_delete=models.CASCADE), ), ]
25.95
168
0.653179
[ "BSD-3-Clause" ]
ip-dolganov/django-filer2.0
filer/migrations/0010_auto_20180414_2058.py
519
Python
import numpy as np from plotly.subplots import make_subplots import plotly.graph_objects as go class BrownianStockSimulator: plot_title = "Simulated White noise, Brownian Motion and Stock Price" plotly_template = "plotly_white" plot_width = 1500 plot_height = 1000 def __init__(self, time_horizon, steps_count, sigma): self.time_horizon = time_horizon self.steps_count = steps_count self.sigma = sigma self.sampling_points = self.time_horizon * self.steps_count self.dt = self.time_horizon / self.sampling_points self.time_grid = self._get_time_grid() def _get_time_grid(self): time_grid = np.arange(0, self.time_horizon + self.dt, self.dt) return time_grid def _get_white_noise(self): white_noise = np.sqrt(self.dt) * np.random.normal( loc=0, scale=1.0, size=self.sampling_points ) return white_noise def _get_brownian_motion(self, white_noise): brownian_motion = np.cumsum(white_noise) brownian_motion = np.append(0, brownian_motion) return brownian_motion def _get_stock_price(self, init_stock_price): output = ( self.sigma * self.brownian_motion - 0.5 * self.sigma ** 2 * self.time_grid ) return init_stock_price * np.exp(output) def simulate(self, init_stock_price, random_seed=42): np.random.seed(random_seed) self.white_noise = self._get_white_noise() self.brownian_motion = self._get_brownian_motion(self.white_noise) self.price = self._get_stock_price(init_stock_price) def plot(self): fig = make_subplots(rows=3, cols=1) fig.append_trace( go.Scatter(x=self.time_grid, y=self.white_noise, name="White Noise"), row=1, col=1, ), fig.append_trace( go.Scatter( x=self.time_grid, y=self.brownian_motion, name="Brownian Motion" ), row=2, col=1, ), fig.append_trace( go.Scatter(x=self.time_grid, y=self.price, name="Stock Price"), row=3, col=1 ) fig.update_layout( height=self.plot_height, width=self.plot_width, title_text=self.plot_title, template=self.plotly_template, ) fig.show()
33.408451
88
0.63027
[ "MIT" ]
coinflip112/stoch_models_for_finance
brownian_stock_simulator.py
2,372
Python
"""Tests for solver module """ # from mathgrid import solver from mathgrid import solver def test_calculator_01(): assert solver.calculator('=((1+3)*2)/(6-4)') == 4 assert solver.calculator('((1+3)*2)/(6-4)') == '((1+3)*2)/(6-4)' assert solver.calculator('=hola') == 'hola'
24.083333
68
0.619377
[ "BSD-2-Clause" ]
logiflo/mathgrid
tests/test_solver.py
289
Python
""" Tests for various datasette helper functions. """ from datasette.app import Datasette from datasette import utils from datasette.utils.asgi import Request from datasette.utils.sqlite import sqlite3 import json import os import pathlib import pytest import tempfile from unittest.mock import patch @pytest.mark.parametrize( "path,expected", [ ("foo", ["foo"]), ("foo,bar", ["foo", "bar"]), ("123,433,112", ["123", "433", "112"]), ("123~2C433,112", ["123,433", "112"]), ("123~2F433~2F112", ["123/433/112"]), ], ) def test_urlsafe_components(path, expected): assert expected == utils.urlsafe_components(path) @pytest.mark.parametrize( "path,added_args,expected", [ ("/foo", {"bar": 1}, "/foo?bar=1"), ("/foo?bar=1", {"baz": 2}, "/foo?bar=1&baz=2"), ("/foo?bar=1&bar=2", {"baz": 3}, "/foo?bar=1&bar=2&baz=3"), ("/foo?bar=1", {"bar": None}, "/foo"), # Test order is preserved ( "/?_facet=prim_state&_facet=area_name", (("prim_state", "GA"),), "/?_facet=prim_state&_facet=area_name&prim_state=GA", ), ( "/?_facet=state&_facet=city&state=MI", (("city", "Detroit"),), "/?_facet=state&_facet=city&state=MI&city=Detroit", ), ( "/?_facet=state&_facet=city", (("_facet", "planet_int"),), "/?_facet=state&_facet=city&_facet=planet_int", ), ], ) def test_path_with_added_args(path, added_args, expected): request = Request.fake(path) actual = utils.path_with_added_args(request, added_args) assert expected == actual @pytest.mark.parametrize( "path,args,expected", [ ("/foo?bar=1", {"bar"}, "/foo"), ("/foo?bar=1&baz=2", {"bar"}, "/foo?baz=2"), ("/foo?bar=1&bar=2&bar=3", {"bar": "2"}, "/foo?bar=1&bar=3"), ], ) def test_path_with_removed_args(path, args, expected): request = Request.fake(path) actual = utils.path_with_removed_args(request, args) assert expected == actual # Run the test again but this time use the path= argument request = Request.fake("/") actual = utils.path_with_removed_args(request, args, path=path) assert expected == actual @pytest.mark.parametrize( "path,args,expected", [ ("/foo?bar=1", {"bar": 2}, "/foo?bar=2"), ("/foo?bar=1&baz=2", {"bar": None}, "/foo?baz=2"), ], ) def test_path_with_replaced_args(path, args, expected): request = Request.fake(path) actual = utils.path_with_replaced_args(request, args) assert expected == actual @pytest.mark.parametrize( "row,pks,expected_path", [ ({"A": "foo", "B": "bar"}, ["A", "B"], "foo,bar"), ({"A": "f,o", "B": "bar"}, ["A", "B"], "f~2Co,bar"), ({"A": 123}, ["A"], "123"), ( utils.CustomRow( ["searchable_id", "tag"], [ ("searchable_id", {"value": 1, "label": "1"}), ("tag", {"value": "feline", "label": "feline"}), ], ), ["searchable_id", "tag"], "1,feline", ), ], ) def test_path_from_row_pks(row, pks, expected_path): actual_path = utils.path_from_row_pks(row, pks, False) assert expected_path == actual_path @pytest.mark.parametrize( "obj,expected", [ ( { "Description": "Soft drinks", "Picture": b"\x15\x1c\x02\xc7\xad\x05\xfe", "CategoryID": 1, }, """ {"CategoryID": 1, "Description": "Soft drinks", "Picture": {"$base64": true, "encoded": "FRwCx60F/g=="}} """.strip(), ) ], ) def test_custom_json_encoder(obj, expected): actual = json.dumps(obj, cls=utils.CustomJSONEncoder, sort_keys=True) assert expected == actual @pytest.mark.parametrize( "bad_sql", [ "update blah;", "-- sql comment to skip\nupdate blah;", "update blah set some_column='# Hello there\n\n* This is a list\n* of items\n--\n[And a link](https://github.com/simonw/datasette-render-markdown).'\nas demo_markdown", "PRAGMA case_sensitive_like = true", "SELECT * FROM pragma_not_on_allow_list('idx52')", ], ) def test_validate_sql_select_bad(bad_sql): with pytest.raises(utils.InvalidSql): utils.validate_sql_select(bad_sql) @pytest.mark.parametrize( "good_sql", [ "select count(*) from airports", "select foo from bar", "--sql comment to skip\nselect foo from bar", "select '# Hello there\n\n* This is a list\n* of items\n--\n[And a link](https://github.com/simonw/datasette-render-markdown).'\nas demo_markdown", "select 1 + 1", "explain select 1 + 1", "explain\nselect 1 + 1", "explain query plan select 1 + 1", "explain query plan\nselect 1 + 1", "SELECT\nblah FROM foo", "WITH RECURSIVE cnt(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 10) SELECT x FROM cnt;", "explain WITH RECURSIVE cnt(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 10) SELECT x FROM cnt;", "explain query plan WITH RECURSIVE cnt(x) AS (SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 10) SELECT x FROM cnt;", "SELECT * FROM pragma_index_info('idx52')", "select * from pragma_table_xinfo('table')", ], ) def test_validate_sql_select_good(good_sql): utils.validate_sql_select(good_sql) @pytest.mark.parametrize("open_quote,close_quote", [('"', '"'), ("[", "]")]) def test_detect_fts(open_quote, close_quote): sql = """ CREATE TABLE "Dumb_Table" ( "TreeID" INTEGER, "qSpecies" TEXT ); CREATE TABLE "Street_Tree_List" ( "TreeID" INTEGER, "qSpecies" TEXT, "qAddress" TEXT, "SiteOrder" INTEGER, "qSiteInfo" TEXT, "PlantType" TEXT, "qCaretaker" TEXT ); CREATE VIEW Test_View AS SELECT * FROM Dumb_Table; CREATE VIRTUAL TABLE {open}Street_Tree_List_fts{close} USING FTS4 ("qAddress", "qCaretaker", "qSpecies", content={open}Street_Tree_List{close}); CREATE VIRTUAL TABLE r USING rtree(a, b, c); """.format( open=open_quote, close=close_quote ) conn = utils.sqlite3.connect(":memory:") conn.executescript(sql) assert None is utils.detect_fts(conn, "Dumb_Table") assert None is utils.detect_fts(conn, "Test_View") assert None is utils.detect_fts(conn, "r") assert "Street_Tree_List_fts" == utils.detect_fts(conn, "Street_Tree_List") @pytest.mark.parametrize("table", ("regular", "has'single quote")) def test_detect_fts_different_table_names(table): sql = """ CREATE TABLE [{table}] ( "TreeID" INTEGER, "qSpecies" TEXT ); CREATE VIRTUAL TABLE [{table}_fts] USING FTS4 ("qSpecies", content="{table}"); """.format( table=table ) conn = utils.sqlite3.connect(":memory:") conn.executescript(sql) assert "{table}_fts".format(table=table) == utils.detect_fts(conn, table) @pytest.mark.parametrize( "url,expected", [ ("http://www.google.com/", True), ("https://example.com/", True), ("www.google.com", False), ("http://www.google.com/ is a search engine", False), ], ) def test_is_url(url, expected): assert expected == utils.is_url(url) @pytest.mark.parametrize( "s,expected", [ ("simple", "simple"), ("MixedCase", "MixedCase"), ("-no-leading-hyphens", "no-leading-hyphens-65bea6"), ("_no-leading-underscores", "no-leading-underscores-b921bc"), ("no spaces", "no-spaces-7088d7"), ("-", "336d5e"), ("no $ characters", "no--characters-59e024"), ], ) def test_to_css_class(s, expected): assert expected == utils.to_css_class(s) def test_temporary_docker_directory_uses_hard_link(): with tempfile.TemporaryDirectory() as td: os.chdir(td) with open("hello", "w") as fp: fp.write("world") # Default usage of this should use symlink with utils.temporary_docker_directory( files=["hello"], name="t", metadata=None, extra_options=None, branch=None, template_dir=None, plugins_dir=None, static=[], install=[], spatialite=False, version_note=None, secret="secret", ) as temp_docker: hello = os.path.join(temp_docker, "hello") with open(hello) as fp: assert "world" == fp.read() # It should be a hard link assert 2 == os.stat(hello).st_nlink @patch("os.link") def test_temporary_docker_directory_uses_copy_if_hard_link_fails(mock_link): # Copy instead if os.link raises OSError (normally due to different device) mock_link.side_effect = OSError with tempfile.TemporaryDirectory() as td: os.chdir(td) with open("hello", "w") as fp: fp.write("world") # Default usage of this should use symlink with utils.temporary_docker_directory( files=["hello"], name="t", metadata=None, extra_options=None, branch=None, template_dir=None, plugins_dir=None, static=[], install=[], spatialite=False, version_note=None, secret=None, ) as temp_docker: hello = os.path.join(temp_docker, "hello") with open(hello) as fp: assert "world" == fp.read() # It should be a copy, not a hard link assert 1 == os.stat(hello).st_nlink def test_temporary_docker_directory_quotes_args(): with tempfile.TemporaryDirectory() as td: os.chdir(td) with open("hello", "w") as fp: fp.write("world") with utils.temporary_docker_directory( files=["hello"], name="t", metadata=None, extra_options="--$HOME", branch=None, template_dir=None, plugins_dir=None, static=[], install=[], spatialite=False, version_note="$PWD", secret="secret", ) as temp_docker: df = os.path.join(temp_docker, "Dockerfile") with open(df) as fp: df_contents = fp.read() assert "'$PWD'" in df_contents assert "'--$HOME'" in df_contents assert "ENV DATASETTE_SECRET 'secret'" in df_contents def test_compound_keys_after_sql(): assert "((a > :p0))" == utils.compound_keys_after_sql(["a"]) assert """ ((a > :p0) or (a = :p0 and b > :p1)) """.strip() == utils.compound_keys_after_sql( ["a", "b"] ) assert """ ((a > :p0) or (a = :p0 and b > :p1) or (a = :p0 and b = :p1 and c > :p2)) """.strip() == utils.compound_keys_after_sql( ["a", "b", "c"] ) async def table_exists(table): return table == "exists.csv" @pytest.mark.asyncio @pytest.mark.parametrize( "table_and_format,expected_table,expected_format", [ ("blah", "blah", None), ("blah.csv", "blah", "csv"), ("blah.json", "blah", "json"), ("blah.baz", "blah.baz", None), ("exists.csv", "exists.csv", None), ], ) async def test_resolve_table_and_format( table_and_format, expected_table, expected_format ): actual_table, actual_format = await utils.resolve_table_and_format( table_and_format, table_exists, ["json"] ) assert expected_table == actual_table assert expected_format == actual_format def test_table_columns(): conn = sqlite3.connect(":memory:") conn.executescript( """ create table places (id integer primary key, name text, bob integer) """ ) assert ["id", "name", "bob"] == utils.table_columns(conn, "places") @pytest.mark.parametrize( "path,format,extra_qs,expected", [ ("/foo?sql=select+1", "csv", {}, "/foo.csv?sql=select+1"), ("/foo?sql=select+1", "json", {}, "/foo.json?sql=select+1"), ("/foo/bar", "json", {}, "/foo/bar.json"), ("/foo/bar", "csv", {}, "/foo/bar.csv"), ("/foo/bar", "csv", {"_dl": 1}, "/foo/bar.csv?_dl=1"), ( "/sf-trees/Street_Tree_List?_search=cherry&_size=1000", "csv", {"_dl": 1}, "/sf-trees/Street_Tree_List.csv?_search=cherry&_size=1000&_dl=1", ), ], ) def test_path_with_format(path, format, extra_qs, expected): request = Request.fake(path) actual = utils.path_with_format(request=request, format=format, extra_qs=extra_qs) assert expected == actual @pytest.mark.parametrize( "bytes,expected", [ (120, "120 bytes"), (1024, "1.0 KB"), (1024 * 1024, "1.0 MB"), (1024 * 1024 * 1024, "1.0 GB"), (1024 * 1024 * 1024 * 1.3, "1.3 GB"), (1024 * 1024 * 1024 * 1024, "1.0 TB"), ], ) def test_format_bytes(bytes, expected): assert expected == utils.format_bytes(bytes) @pytest.mark.parametrize( "query,expected", [ ("dog", '"dog"'), ("cat,", '"cat,"'), ("cat dog", '"cat" "dog"'), # If a phrase is already double quoted, leave it so ('"cat dog"', '"cat dog"'), ('"cat dog" fish', '"cat dog" "fish"'), # Sensibly handle unbalanced double quotes ('cat"', '"cat"'), ('"cat dog" "fish', '"cat dog" "fish"'), ], ) def test_escape_fts(query, expected): assert expected == utils.escape_fts(query) @pytest.mark.parametrize( "input,expected", [ ("dog", "dog"), ('dateutil_parse("1/2/2020")', r"dateutil_parse(\0000221/2/2020\000022)"), ("this\r\nand\r\nthat", r"this\00000Aand\00000Athat"), ], ) def test_escape_css_string(input, expected): assert expected == utils.escape_css_string(input) def test_check_connection_spatialite_raises(): path = str(pathlib.Path(__file__).parent / "spatialite.db") conn = sqlite3.connect(path) with pytest.raises(utils.SpatialiteConnectionProblem): utils.check_connection(conn) def test_check_connection_passes(): conn = sqlite3.connect(":memory:") utils.check_connection(conn) def test_call_with_supported_arguments(): def foo(a, b): return f"{a}+{b}" assert "1+2" == utils.call_with_supported_arguments(foo, a=1, b=2) assert "1+2" == utils.call_with_supported_arguments(foo, a=1, b=2, c=3) with pytest.raises(TypeError): utils.call_with_supported_arguments(foo, a=1) @pytest.mark.parametrize( "data,should_raise", [ ([["foo", "bar"], ["foo", "baz"]], False), ([("foo", "bar"), ("foo", "baz")], False), ((["foo", "bar"], ["foo", "baz"]), False), ([["foo", "bar"], ["foo", "baz", "bax"]], True), ({"foo": ["bar", "baz"]}, False), ({"foo": ("bar", "baz")}, False), ({"foo": "bar"}, True), ], ) def test_multi_params(data, should_raise): if should_raise: with pytest.raises(AssertionError): utils.MultiParams(data) return p1 = utils.MultiParams(data) assert "bar" == p1["foo"] assert ["bar", "baz"] == list(p1.getlist("foo")) @pytest.mark.parametrize( "actor,allow,expected", [ # Default is to allow: (None, None, True), # {} means deny-all: (None, {}, False), ({"id": "root"}, {}, False), # true means allow-all ({"id": "root"}, True, True), (None, True, True), # false means deny-all ({"id": "root"}, False, False), (None, False, False), # Special case for "unauthenticated": true (None, {"unauthenticated": True}, True), (None, {"unauthenticated": False}, False), # Match on just one property: (None, {"id": "root"}, False), ({"id": "root"}, None, True), ({"id": "simon", "staff": True}, {"staff": True}, True), ({"id": "simon", "staff": False}, {"staff": True}, False), # Special "*" value for any key: ({"id": "root"}, {"id": "*"}, True), ({}, {"id": "*"}, False), ({"name": "root"}, {"id": "*"}, False), # Supports single strings or list of values: ({"id": "root"}, {"id": "bob"}, False), ({"id": "root"}, {"id": ["bob"]}, False), ({"id": "root"}, {"id": "root"}, True), ({"id": "root"}, {"id": ["root"]}, True), # Any matching role will work: ({"id": "garry", "roles": ["staff", "dev"]}, {"roles": ["staff"]}, True), ({"id": "garry", "roles": ["staff", "dev"]}, {"roles": ["dev"]}, True), ({"id": "garry", "roles": ["staff", "dev"]}, {"roles": ["otter"]}, False), ({"id": "garry", "roles": ["staff", "dev"]}, {"roles": ["dev", "otter"]}, True), ({"id": "garry", "roles": []}, {"roles": ["staff"]}, False), ({"id": "garry"}, {"roles": ["staff"]}, False), # Any single matching key works: ({"id": "root"}, {"bot_id": "my-bot", "id": ["root"]}, True), ], ) def test_actor_matches_allow(actor, allow, expected): assert expected == utils.actor_matches_allow(actor, allow) @pytest.mark.parametrize( "config,expected", [ ({"foo": "bar"}, {"foo": "bar"}), ({"$env": "FOO"}, "x"), ({"k": {"$env": "FOO"}}, {"k": "x"}), ([{"k": {"$env": "FOO"}}, {"z": {"$env": "FOO"}}], [{"k": "x"}, {"z": "x"}]), ({"k": [{"in_a_list": {"$env": "FOO"}}]}, {"k": [{"in_a_list": "x"}]}), ], ) def test_resolve_env_secrets(config, expected): assert expected == utils.resolve_env_secrets(config, {"FOO": "x"}) @pytest.mark.parametrize( "actor,expected", [ ({"id": "blah"}, "blah"), ({"id": "blah", "login": "l"}, "l"), ({"id": "blah", "login": "l"}, "l"), ({"id": "blah", "login": "l", "username": "u"}, "u"), ({"login": "l", "name": "n"}, "n"), ( {"id": "blah", "login": "l", "username": "u", "name": "n", "display": "d"}, "d", ), ({"weird": "shape"}, "{'weird': 'shape'}"), ], ) def test_display_actor(actor, expected): assert expected == utils.display_actor(actor) @pytest.mark.asyncio @pytest.mark.parametrize( "dbs,expected_path", [ (["one_table"], "/one/one"), (["two_tables"], "/two"), (["one_table", "two_tables"], "/"), ], ) async def test_initial_path_for_datasette(tmp_path_factory, dbs, expected_path): db_dir = tmp_path_factory.mktemp("dbs") one_table = str(db_dir / "one.db") sqlite3.connect(one_table).execute("create table one (id integer primary key)") two_tables = str(db_dir / "two.db") sqlite3.connect(two_tables).execute("create table two (id integer primary key)") sqlite3.connect(two_tables).execute("create table three (id integer primary key)") datasette = Datasette( [{"one_table": one_table, "two_tables": two_tables}[db] for db in dbs] ) path = await utils.initial_path_for_datasette(datasette) assert path == expected_path @pytest.mark.parametrize( "content,expected", ( ("title: Hello", {"title": "Hello"}), ('{"title": "Hello"}', {"title": "Hello"}), ("{{ this }} is {{ bad }}", None), ), ) def test_parse_metadata(content, expected): if expected is None: with pytest.raises(utils.BadMetadataError): utils.parse_metadata(content) else: assert utils.parse_metadata(content) == expected @pytest.mark.asyncio @pytest.mark.parametrize( "sql,expected", ( ("select 1", []), ("select 1 + :one", ["one"]), ("select 1 + :one + :two", ["one", "two"]), ("select 'bob' || '0:00' || :cat", ["cat"]), ("select this is invalid :one, :two, :three", ["one", "two", "three"]), ), ) async def test_derive_named_parameters(sql, expected): ds = Datasette([], memory=True) db = ds.get_database("_memory") params = await utils.derive_named_parameters(db, sql) assert params == expected @pytest.mark.parametrize( "original,expected", ( ("abc", "abc"), ("/foo/bar", "~2Ffoo~2Fbar"), ("/-/bar", "~2F-~2Fbar"), ("-/db-/table.csv", "-~2Fdb-~2Ftable~2Ecsv"), (r"%~-/", "~25~7E-~2F"), ("~25~7E~2D~2F", "~7E25~7E7E~7E2D~7E2F"), ), ) def test_tilde_encoding(original, expected): actual = utils.tilde_encode(original) assert actual == expected # And test round-trip assert original == utils.tilde_decode(actual)
31.74732
176
0.556268
[ "Apache-2.0" ]
chriswedgwood/datasette
tests/test_utils.py
20,731
Python
import pgzero import pgzrun import random from pgzero.actor import Actor __all__ = ["pgzrun", "pgzero"] from pgzero.clock import clock from pgzero.keyboard import keyboard from pgzero.loaders import sounds clouds = [Actor('cloud1', (200, 200)), Actor('cloud2', (400, 300)), Actor('cloud3', (600, 200)), Actor('cloud1', (800, 300))] obstacles = [Actor('cactus', (random.randint(900, 1000), 495)), Actor('cactus', (random.randint(1200, 1500), 495)), Actor('cactus', (random.randint(1500, 2000), 495))] player = Actor('p3_stand', (100, 484)) # 0 - game not started # 1 - game just stared # 2 - finished game = 0 # frame that is currently running frame = 0 # player movement speed and direction jump = 0 # 0 - jump is available # 1 - jump is forbidden jump_blocked = 0 cloud_speed = 2 game_time = 0 # cactus movement speed game_speed = 8 # 0 - game running # 1 - game blocked jump_unblocked = 0 def draw(): global game screen.clear() screen.fill('#cff4f7') for i in range((screen.width // 70) + 1): screen.blit('grass', (i * 70, screen.height - 70)) for cloud in clouds: cloud.draw() for obstacle in obstacles: obstacle.draw() screen.draw.text( align_text_time(game_time), midright=(screen.width - 50, 50), fontname="roboto_mono_bold", color="orange", fontsize=45 ) player.draw() if game == 0: screen.draw.text( "Wcisnij spacje", center=(screen.width / 2, screen.height / 2), color="orange", fontsize=60 ) if game == 2: screen.draw.text( "Koniec gry", center=(screen.width / 2, screen.height / 2), color="red", fontsize=60 ) screen.draw.text( "Wcisnij spacje aby zagrac jeszcze raz", center=(screen.width / 2, screen.height - 200), color="red", fontsize=30 ) def update(): global game global jump global jump_blocked global jump_unblocked if keyboard.SPACE and jump_unblocked == 0: if game == 0 or game == 2: jump_blocked = 1 clock.schedule_unique(unblock_jump, 0.3) reset() game = 1 if jump_blocked == 0: jump = -18 jump_blocked = 1 sounds.jingles_jump.play() animation() jump_fall() move_cloud() move_obstacle() check_collision() # change difficulty level, increase game and clouds speed def change_difficulty_level(): global game_speed global cloud_speed if game_speed < 16: game_speed += 1 cloud_speed += 1 # reset global variables def reset(): global frame global game global jump global jump_blocked global cloud_speed global game_speed global game_time if game == 2: frame = 0 game = 0 jump = 0 jump_blocked = 1 cloud_speed = 2 game_speed = 8 game_time = 0 player.pos = (100, 484) clouds[0].pos = (200, 200) clouds[1].pos = (400, 300) clouds[2].pos = (600, 200) clouds[3].pos = (800, 300) obstacles[0].pos = (random.randint(900, 1000), 495) obstacles[1].pos = (random.randint(1200, 1500), 495) obstacles[2].pos = (random.randint(1500, 2000), 495) clock.unschedule(change_difficulty_level) # change difficulty level every 20s clock.schedule_interval(change_difficulty_level, 20) def unblock_game(): global jump_unblocked jump_unblocked = 0 # check collision with cactus def check_collision(): global game global jump_unblocked if game == 1: for i in obstacles: if player.collidepoint(i.x, i.y): game = 2 sounds.jingles_end.play() jump_unblocked = 1 # unblock game in 2 sec clock.schedule_unique(unblock_game, 2.0) def move_obstacle(): global game_speed global game if game == 1: for i in range(len(obstacles)): # decrease x for all obstacles about speed value obstacles[i].x -= game_speed # if obstacles is out of screen get random position if obstacles[i].x + 35 < 0: obstacles[i].x = random.randint(900, 1500) # if obstacles have the same position as other or is too close, move it about 400 for j in range(0, len(obstacles)): if j != i and abs(obstacles[i].x - obstacles[j].x < 300): obstacles[i].x += 400 # triggered every 0.1s increasing game time about 1s def measure_time(): global game_time global game if game == 0: game_time = 0 elif game == 1: game_time +=1 def align_text_time(time): text = "0" * (5 - len(str(time))) text += str(time) return text def move_cloud(): global cloud_speed global game if game == 1: # move clouds x pos about cloud speed for cloud in clouds: cloud.x -= cloud_speed # if cloud out of screen move it to right side if cloud.x + 64 < 0: cloud.x = screen.width + 32 def unblock_jump(): global jump_blocked jump_blocked = 0 def jump_fall(): global jump global frame if jump != 0: # block animation frame = 0 player.y += jump # if player on the ground unblock if player.y >= 484: unblock_jump() jump = 0 # if player jumped start falling if player.y <= 250: jump *= (-1) # player animation def animation(): global frame if game == 1: if frame == 0: player.image = 'p3_walk01' if frame == 1: player.image = 'p3_walk02' if frame == 2: player.image = 'p3_walk03' if frame == 3: player.image = 'p3_walk04' if frame == 4: player.image = 'p3_walk05' if frame == 5: player.image = 'p3_walk06' if frame == 6: player.image = 'p3_walk07' if frame == 7: player.image = 'p3_walk08' if frame == 8: player.image = 'p3_walk09' if frame == 9: player.image = 'p3_walk10' if frame == 10: player.image = 'p3_walk11' frame += 1 # result is 0 or less than 11 frame %= 11 clock.schedule_interval(measure_time, 0.1) clock.schedule_interval(change_difficulty_level, 20) pgzrun.go()
24.791822
97
0.562453
[ "MIT" ]
bartlomiej-kedziora/games
dino/main.py
6,669
Python
""" A pure python (slow) implementation of rijndael with a decent interface To include - from rijndael import rijndael To do a key setup - r = rijndael(key, block_size = 16) key must be a string of length 16, 24, or 32 blocksize must be 16, 24, or 32. Default is 16 To use - ciphertext = r.encrypt(plaintext) plaintext = r.decrypt(ciphertext) If any strings are of the wrong length a ValueError is thrown """ # ported from the Java reference code by Bram Cohen, April 2001 # this code is public domain, unless someone makes # an intellectual property claim against the reference # code, in which case it can be made public domain by # deleting all the comments and renaming all the variables import copy import string shifts = [[[0, 0], [1, 3], [2, 2], [3, 1]], [[0, 0], [1, 5], [2, 4], [3, 3]], [[0, 0], [1, 7], [3, 5], [4, 4]]] # [keysize][block_size] num_rounds = {16: {16: 10, 24: 12, 32: 14}, 24: {16: 12, 24: 12, 32: 14}, 32: {16: 14, 24: 14, 32: 14}} A = [[1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 1, 1, 1, 1, 1], [1, 0, 0, 0, 1, 1, 1, 1], [1, 1, 0, 0, 0, 1, 1, 1], [1, 1, 1, 0, 0, 0, 1, 1], [1, 1, 1, 1, 0, 0, 0, 1]] # produce log and alog tables, needed for multiplying in the # field GF(2^m) (generator = 3) alog = [1] for i in range(255): j = (alog[-1] << 1) ^ alog[-1] if j & 0x100 != 0: j ^= 0x11B alog.append(j) log = [0] * 256 for i in range(1, 255): log[alog[i]] = i # multiply two elements of GF(2^m) def mul(a, b): if a == 0 or b == 0: return 0 return alog[(log[a & 0xFF] + log[b & 0xFF]) % 255] # substitution box based on F^{-1}(x) box = [[0] * 8 for i in range(256)] box[1][7] = 1 for i in range(2, 256): j = alog[255 - log[i]] for t in range(8): box[i][t] = (j >> (7 - t)) & 0x01 B = [0, 1, 1, 0, 0, 0, 1, 1] # affine transform: box[i] <- B + A*box[i] cox = [[0] * 8 for i in range(256)] for i in range(256): for t in range(8): cox[i][t] = B[t] for j in range(8): cox[i][t] ^= A[t][j] * box[i][j] # S-boxes and inverse S-boxes S = [0] * 256 Si = [0] * 256 for i in range(256): S[i] = cox[i][0] << 7 for t in range(1, 8): S[i] ^= cox[i][t] << (7-t) Si[S[i] & 0xFF] = i # T-boxes G = [[2, 1, 1, 3], [3, 2, 1, 1], [1, 3, 2, 1], [1, 1, 3, 2]] AA = [[0] * 8 for i in range(4)] for i in range(4): for j in range(4): AA[i][j] = G[i][j] AA[i][i+4] = 1 for i in range(4): pivot = AA[i][i] if pivot == 0: t = i + 1 while AA[t][i] == 0 and t < 4: t += 1 assert t != 4, 'G matrix must be invertible' for j in range(8): AA[i][j], AA[t][j] = AA[t][j], AA[i][j] pivot = AA[i][i] for j in range(8): if AA[i][j] != 0: AA[i][j] = alog[(255 + log[AA[i][j] & 0xFF] - log[pivot & 0xFF]) % 255] for t in range(4): if i != t: for j in range(i+1, 8): AA[t][j] ^= mul(AA[i][j], AA[t][i]) AA[t][i] = 0 iG = [[0] * 4 for i in range(4)] for i in range(4): for j in range(4): iG[i][j] = AA[i][j + 4] def mul4(a, bs): if a == 0: return 0 r = 0 for b in bs: r <<= 8 if b != 0: r = r | mul(a, b) return r T1 = [] T2 = [] T3 = [] T4 = [] T5 = [] T6 = [] T7 = [] T8 = [] U1 = [] U2 = [] U3 = [] U4 = [] for t in range(256): s = S[t] T1.append(mul4(s, G[0])) T2.append(mul4(s, G[1])) T3.append(mul4(s, G[2])) T4.append(mul4(s, G[3])) s = Si[t] T5.append(mul4(s, iG[0])) T6.append(mul4(s, iG[1])) T7.append(mul4(s, iG[2])) T8.append(mul4(s, iG[3])) U1.append(mul4(t, iG[0])) U2.append(mul4(t, iG[1])) U3.append(mul4(t, iG[2])) U4.append(mul4(t, iG[3])) # round constants rcon = [1] r = 1 for t in range(1, 30): r = mul(2, r) rcon.append(r) del A del AA del pivot del B del G del box del log del alog del i del j del r del s del t del mul del mul4 del cox del iG class rijndael(object): def __init__(self, key, block_size = 16): if block_size != 16 and block_size != 24 and block_size != 32: raise ValueError('Invalid block size: ' + str(block_size)) if len(key) != 16 and len(key) != 24 and len(key) != 32: raise ValueError('Invalid key size: ' + str(len(key))) self.block_size = block_size ROUNDS = num_rounds[len(key)][block_size] BC = block_size // 4 # encryption round keys Ke = [[0] * BC for i in range(ROUNDS + 1)] # decryption round keys Kd = [[0] * BC for i in range(ROUNDS + 1)] ROUND_KEY_COUNT = (ROUNDS + 1) * BC KC = len(key) // 4 # copy user material bytes into temporary ints tk = [] for i in range(0, KC): tk.append((ord(key[i * 4]) << 24) | (ord(key[i * 4 + 1]) << 16) | (ord(key[i * 4 + 2]) << 8) | ord(key[i * 4 + 3])) # copy values into round key arrays t = 0 j = 0 while j < KC and t < ROUND_KEY_COUNT: Ke[t // BC][t % BC] = tk[j] Kd[ROUNDS - (t // BC)][t % BC] = tk[j] j += 1 t += 1 tt = 0 rconpointer = 0 while t < ROUND_KEY_COUNT: # extrapolate using phi (the round key evolution function) tt = tk[KC - 1] tk[0] ^= (S[(tt >> 16) & 0xFF] & 0xFF) << 24 ^ \ (S[(tt >> 8) & 0xFF] & 0xFF) << 16 ^ \ (S[ tt & 0xFF] & 0xFF) << 8 ^ \ (S[(tt >> 24) & 0xFF] & 0xFF) ^ \ (rcon[rconpointer] & 0xFF) << 24 rconpointer += 1 if KC != 8: for i in range(1, KC): tk[i] ^= tk[i-1] else: for i in range(1, KC // 2): tk[i] ^= tk[i-1] tt = tk[KC // 2 - 1] tk[KC // 2] ^= (S[ tt & 0xFF] & 0xFF) ^ \ (S[(tt >> 8) & 0xFF] & 0xFF) << 8 ^ \ (S[(tt >> 16) & 0xFF] & 0xFF) << 16 ^ \ (S[(tt >> 24) & 0xFF] & 0xFF) << 24 for i in range(KC // 2 + 1, KC): tk[i] ^= tk[i-1] # copy values into round key arrays j = 0 while j < KC and t < ROUND_KEY_COUNT: Ke[t // BC][t % BC] = tk[j] Kd[ROUNDS - (t // BC)][t % BC] = tk[j] j += 1 t += 1 # inverse MixColumn where needed for r in range(1, ROUNDS): for j in range(BC): tt = Kd[r][j] Kd[r][j] = U1[(tt >> 24) & 0xFF] ^ \ U2[(tt >> 16) & 0xFF] ^ \ U3[(tt >> 8) & 0xFF] ^ \ U4[ tt & 0xFF] self.Ke = Ke self.Kd = Kd def encrypt(self, plaintext): if len(plaintext) != self.block_size: raise ValueError('wrong block length, expected ' + str(self.block_size) + ' got ' + str(len(plaintext))) Ke = self.Ke BC = self.block_size // 4 ROUNDS = len(Ke) - 1 if BC == 4: SC = 0 elif BC == 6: SC = 1 else: SC = 2 s1 = shifts[SC][1][0] s2 = shifts[SC][2][0] s3 = shifts[SC][3][0] a = [0] * BC # temporary work array t = [] # plaintext to ints + key for i in range(BC): t.append((ord(plaintext[i * 4 ]) << 24 | ord(plaintext[i * 4 + 1]) << 16 | ord(plaintext[i * 4 + 2]) << 8 | ord(plaintext[i * 4 + 3]) ) ^ Ke[0][i]) # apply round transforms for r in range(1, ROUNDS): for i in range(BC): a[i] = (T1[(t[ i ] >> 24) & 0xFF] ^ T2[(t[(i + s1) % BC] >> 16) & 0xFF] ^ T3[(t[(i + s2) % BC] >> 8) & 0xFF] ^ T4[ t[(i + s3) % BC] & 0xFF] ) ^ Ke[r][i] t = copy.copy(a) # last round is special result = [] for i in range(BC): tt = Ke[ROUNDS][i] result.append((S[(t[ i ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF) result.append((S[(t[(i + s1) % BC] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF) result.append((S[(t[(i + s2) % BC] >> 8) & 0xFF] ^ (tt >> 8)) & 0xFF) result.append((S[ t[(i + s3) % BC] & 0xFF] ^ tt ) & 0xFF) return ''.join(map(chr, result)) def decrypt(self, ciphertext): if len(ciphertext) != self.block_size: raise ValueError('wrong block length, expected ' + str(self.block_size) + ' got ' + str(len(ciphertext))) Kd = self.Kd BC = self.block_size // 4 ROUNDS = len(Kd) - 1 if BC == 4: SC = 0 elif BC == 6: SC = 1 else: SC = 2 s1 = shifts[SC][1][1] s2 = shifts[SC][2][1] s3 = shifts[SC][3][1] a = [0] * BC # temporary work array t = [0] * BC # ciphertext to ints + key for i in range(BC): t[i] = (ord(ciphertext[i * 4 ]) << 24 | ord(ciphertext[i * 4 + 1]) << 16 | ord(ciphertext[i * 4 + 2]) << 8 | ord(ciphertext[i * 4 + 3]) ) ^ Kd[0][i] # apply round transforms for r in range(1, ROUNDS): for i in range(BC): a[i] = (T5[(t[ i ] >> 24) & 0xFF] ^ T6[(t[(i + s1) % BC] >> 16) & 0xFF] ^ T7[(t[(i + s2) % BC] >> 8) & 0xFF] ^ T8[ t[(i + s3) % BC] & 0xFF] ) ^ Kd[r][i] t = copy.copy(a) # last round is special result = [] for i in range(BC): tt = Kd[ROUNDS][i] result.append((Si[(t[ i ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF) result.append((Si[(t[(i + s1) % BC] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF) result.append((Si[(t[(i + s2) % BC] >> 8) & 0xFF] ^ (tt >> 8)) & 0xFF) result.append((Si[ t[(i + s3) % BC] & 0xFF] ^ tt ) & 0xFF) return ''.join(map(chr, result)) def encrypt(key, block): return rijndael(key, len(block)).encrypt(block) def decrypt(key, block): return rijndael(key, len(block)).decrypt(block) def t(kl, bl): b = 'b' * bl r = rijndael('a' * kl, bl) assert r.decrypt(r.encrypt(b)) == b def multiple_calls(N): for _ in xrange(N): t(16, 24) t(16, 32) t(24, 16) t(24, 24) t(24, 32) t(32, 16) t(32, 24) t(32, 32) if __name__ == '__main__': n_repeats = 50 multiple_calls(n_repeats)
28.871728
117
0.430683
[ "Apache-2.0" ]
codeclimate-testing/falcon
benchmarks/crypto.py
11,029
Python
# (c) 2019, NetApp, Inc # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) ''' unit tests for Ansible module: na_ontap_rest_cli''' from __future__ import (absolute_import, division, print_function) __metaclass__ = type import json import pytest from ansible.module_utils import basic from ansible.module_utils._text import to_bytes from ansible_collections.netapp.ontap.tests.unit.compat import unittest from ansible_collections.netapp.ontap.tests.unit.compat.mock import patch import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils from ansible_collections.netapp.ontap.plugins.modules.na_ontap_rest_cli \ import NetAppONTAPCommandREST as rest_cli_module, main # module under test if not netapp_utils.has_netapp_lib(): pytestmark = pytest.mark.skip('skipping as missing required netapp_lib') # REST API canned responses when mocking send_request SRR = { # common responses 'is_rest': (200, {}, None), 'empty_good': (200, {}, None), 'end_of_sequence': (500, None, "Ooops, the UT needs one more SRR response"), 'generic_error': (400, None, "Expected error"), # module specific response 'allow': (200, {'Allow': ['GET', 'WHATEVER']}, None) } def set_module_args(args): """prepare arguments so that they will be picked up during module creation""" args = json.dumps({'ANSIBLE_MODULE_ARGS': args}) basic._ANSIBLE_ARGS = to_bytes(args) # pylint: disable=protected-access class AnsibleExitJson(Exception): """Exception class to be raised by module.exit_json and caught by the test case""" class AnsibleFailJson(Exception): """Exception class to be raised by module.fail_json and caught by the test case""" def exit_json(*args, **kwargs): # pylint: disable=unused-argument """function to patch over exit_json; package return data into an exception""" if 'changed' not in kwargs: kwargs['changed'] = False raise AnsibleExitJson(kwargs) def fail_json(*args, **kwargs): # pylint: disable=unused-argument """function to patch over fail_json; package return data into an exception""" kwargs['failed'] = True raise AnsibleFailJson(kwargs) class TestMyModule(unittest.TestCase): ''' Unit tests for na_ontap_job_schedule ''' def setUp(self): self.mock_module_helper = patch.multiple(basic.AnsibleModule, exit_json=exit_json, fail_json=fail_json) self.mock_module_helper.start() self.addCleanup(self.mock_module_helper.stop) def mock_args(self): return { 'hostname': 'test', 'username': 'test_user', 'password': 'test_pass!', 'https': False, 'command': 'volume', 'verb': 'GET', 'params': {'fields': 'size,percent_used'} } def get_cli_mock_object(self): # For rest, mocking is achieved through side_effect return rest_cli_module() def test_module_fail_when_required_args_missing(self): ''' required arguments are reported as errors ''' with pytest.raises(AnsibleFailJson) as exc: set_module_args({}) rest_cli_module() print('Info: %s' % exc.value.args[0]['msg']) @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.OntapRestAPI.send_request') def test_rest_cli(self, mock_request): data = dict(self.mock_args()) set_module_args(data) mock_request.side_effect = [ SRR['is_rest'], SRR['empty_good'], SRR['end_of_sequence'] ] with pytest.raises(AnsibleExitJson) as exc: self.get_cli_mock_object().apply() assert exc.value.args[0]['changed'] @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.OntapRestAPI.send_request') def test_rest_cli_options(self, mock_request): data = dict(self.mock_args()) data['verb'] = 'OPTIONS' set_module_args(data) mock_request.side_effect = [ SRR['is_rest'], SRR['allow'], SRR['end_of_sequence'] ] with pytest.raises(AnsibleExitJson) as exc: self.get_cli_mock_object().apply() assert exc.value.args[0]['changed'] assert 'Allow' in exc.value.args[0]['msg'] @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.OntapRestAPI.send_request') def test_negative_connection_error(self, mock_request): data = dict(self.mock_args()) data['verb'] = 'OPTIONS' set_module_args(data) mock_request.side_effect = [ SRR['generic_error'], SRR['end_of_sequence'] ] with pytest.raises(AnsibleFailJson) as exc: self.get_cli_mock_object().apply() msg = "failed to connect to REST over test: ['Expected error']. Use na_ontap_command for non-rest CLI." assert msg in exc.value.args[0]['msg'] @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.OntapRestAPI.send_request') def check_verb(self, verb, mock_request): data = dict(self.mock_args()) data['verb'] = verb set_module_args(data) mock_request.side_effect = [ SRR['is_rest'], SRR['allow'], SRR['end_of_sequence'] ] with pytest.raises(AnsibleExitJson) as exc: self.get_cli_mock_object().apply() assert exc.value.args[0]['changed'] assert 'Allow' in exc.value.args[0]['msg'] assert mock_request.call_args[0][0] == verb def test_verbs(self): for verb in ['POST', 'DELETE', 'PATCH', 'OPTIONS', 'PATCH']: self.check_verb(verb) @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.OntapRestAPI.send_request') def test_negative_verb(self, mock_request): data = dict(self.mock_args()) data['verb'] = 'GET' set_module_args(data) mock_request.side_effect = [ SRR['is_rest'], SRR['end_of_sequence'] ] uut = self.get_cli_mock_object() with pytest.raises(AnsibleFailJson) as exc: uut.verb = 'INVALID' uut.run_command() msg = 'Error: unexpected verb INVALID' assert msg in exc.value.args[0]['msg'] @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.OntapRestAPI.send_request') def test_negative_error(self, mock_request): data = dict(self.mock_args()) data['verb'] = 'GET' set_module_args(data) mock_request.side_effect = [ SRR['is_rest'], SRR['generic_error'], SRR['end_of_sequence'] ] with pytest.raises(AnsibleFailJson) as exc: main() msg = 'Error: Expected error' assert msg in exc.value.args[0]['msg']
37.262032
112
0.644087
[ "MIT" ]
elixir-no-nels/usegalaxy
venv/lib/python3.6/site-packages/ansible_collections/netapp/ontap/tests/unit/plugins/modules/test_na_ontap_rest_cli.py
6,968
Python
# Copyright 2016 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Some common SessionRunHook classes. @@ """ from __future__ import absolute_import from __future__ import division from __future__ import print_function import os import time import numpy as np import six from tensorflow.contrib.framework.python.ops import variables as contrib_variables from tensorflow.contrib.learn.python.learn import session_run_hook from tensorflow.contrib.learn.python.learn.session_run_hook import SessionRunArgs from tensorflow.contrib.learn.python.learn.summary_writer_cache import SummaryWriterCache from tensorflow.core.framework.summary_pb2 import Summary from tensorflow.core.util.event_pb2 import SessionLog from tensorflow.python.framework import ops from tensorflow.python.platform import tf_logging as logging from tensorflow.python.training import training_util class LoggingTensorHook(session_run_hook.SessionRunHook): """Prints given tensors every N iteration. The tensors will be printed to the log, with `INFO` severity. """ def __init__(self, tensors, every_n_iter=100): """Initializes a LoggingHook monitor. Args: tensors: `dict` of tag to tensors/names or `iterable` of tensors/names. every_n_iter: `int`, print every N iteration. Raises: ValueError: if `every_n_iter` is non-positive. """ if every_n_iter <= 0: raise ValueError("Invalid every_n_iter=%s." % every_n_iter) if not isinstance(tensors, dict): tensors = {item: item for item in tensors} self._tensors = tensors self._every_n_iter = every_n_iter def begin(self): self._iter_count = 0 # Convert names to tensors if given self._current_tensors = {tag: _as_graph_element(tensor) for (tag, tensor) in self._tensors.items()} def before_run(self, run_context): # pylint: disable=unused-argument if self._iter_count % self._every_n_iter == 0: return SessionRunArgs(self._current_tensors) else: return None def after_run(self, run_context, run_values): _ = run_context if self._iter_count % self._every_n_iter == 0: stats = [] for tag in sorted(self._current_tensors.keys()): stats.append("%s = %s" % (tag, run_values.results[tag])) logging.info("%s", ", ".join(stats)) self._iter_count += 1 class StopAtStepHook(session_run_hook.SessionRunHook): """Monitor to request stop at a specified step.""" def __init__(self, num_steps=None, last_step=None): """Create a StopAtStep Hook. This hook requests stop after either a number of steps have been executed or a last step has been reached. Only of the two options can be specified. if `num_steps` is specified, it indicates the number of steps to execute after `begin()` is called. If instead `last_step` is specified, it indicates the last step we want to execute, as passed to the `after_run()` call. Args: num_steps: Number of steps to execute. last_step: Step after which to stop. Raises: ValueError: If one of the arguments is invalid. """ if num_steps is None and last_step is None: raise ValueError("One of num_steps or last_step must be specified.") if num_steps is not None and last_step is not None: raise ValueError("Only one of num_steps or last_step can be specified.") self._num_steps = num_steps self._last_step = last_step def begin(self): self._global_step_tensor = contrib_variables.get_global_step() if self._global_step_tensor is None: raise RuntimeError("Global step should be created to use StopAtStepHook.") def before_run(self, run_context): # pylint: disable=unused-argument return SessionRunArgs(self._global_step_tensor) def after_run(self, run_context, run_values): global_step = run_values.results if self._last_step is None: self._last_step = global_step + self._num_steps - 1 if global_step >= self._last_step: run_context.request_stop() class CheckpointSaverHook(session_run_hook.SessionRunHook): """Saves checkpoints every N steps or seconds.""" def __init__(self, checkpoint_dir, save_secs=None, save_steps=None, saver=None, checkpoint_basename="model.ckpt", scaffold=None): """Initialize CheckpointSaverHook monitor. Args: checkpoint_dir: `str`, base directory for the checkpoint files. save_secs: `int`, save every N secs. save_steps: `int`, save every N steps. saver: `Saver` object, used for saving. checkpoint_basename: `str`, base name for the checkpoint files. scaffold: `Scaffold`, use to get saver object. Raises: ValueError: One of `save_steps` or `save_secs` should be set. """ logging.info("Create CheckpointSaverHook.") self._saver = saver self._checkpoint_dir = checkpoint_dir self._summary_writer = SummaryWriterCache.get(checkpoint_dir) self._save_path = os.path.join(checkpoint_dir, checkpoint_basename) self._scaffold = scaffold self._save_secs = save_secs self._save_steps = save_steps self._last_saved_time = None self._last_saved_step = None if save_steps is None and save_secs is None: raise ValueError("Either save_steps or save_secs should be provided") if (save_steps is not None) and (save_secs is not None): raise ValueError("Can not provide both save_steps and save_secs.") def begin(self): self._last_saved_time = None self._last_saved_step = None self._global_step_tensor = contrib_variables.get_global_step() if self._global_step_tensor is None: raise RuntimeError( "Global step should be created to use CheckpointSaverHook.") def before_run(self, run_context): # pylint: disable=unused-argument if self._last_saved_time is None: # Write graph in the first call. training_util.write_graph( ops.get_default_graph().as_graph_def(add_shapes=True), self._checkpoint_dir, "graph.pbtxt") self._summary_writer.add_graph(ops.get_default_graph()) return SessionRunArgs(self._global_step_tensor) def after_run(self, run_context, run_values): global_step = run_values.results if self._last_saved_time is None: self._save(global_step, run_context.session) if self._save_steps is not None: if global_step >= self._last_saved_step + self._save_steps: self._save(global_step, run_context.session) if self._save_secs is not None: if time.time() >= self._last_saved_time + self._save_secs: self._save(global_step, run_context.session) def end(self, session): last_step = session.run(contrib_variables.get_global_step()) self._save(last_step, session) def _save(self, step, session): """Saves the latest checkpoint.""" if step == self._last_saved_step: return logging.info("Saving checkpoints for %d into %s.", step, self._save_path) self._last_saved_time = time.time() self._last_saved_step = step if self._saver is None: self._scaffold.saver.save(session, self._save_path, global_step=step) else: self._saver.save(session, self._save_path, global_step=step) self._summary_writer.add_session_log( SessionLog( status=SessionLog.CHECKPOINT, checkpoint_path=self._save_path), step) class StepCounterHook(session_run_hook.SessionRunHook): """Steps per second monitor.""" def __init__(self, every_n_steps=100, output_dir=None, summary_writer=None): self._summary_tag = "global_step/sec" self._every_n_steps = every_n_steps self._summary_writer = summary_writer if summary_writer is None and output_dir: self._summary_writer = SummaryWriterCache.get(output_dir) def begin(self): self._last_reported_time = None self._last_reported_step = None self._global_step_tensor = contrib_variables.get_global_step() if self._global_step_tensor is None: raise RuntimeError( "Global step should be created to use StepCounterHook.") def before_run(self, run_context): # pylint: disable=unused-argument return SessionRunArgs(self._global_step_tensor) def after_run(self, run_context, run_values): _ = run_context if not self._summary_writer: return global_step = run_values.results current_time = time.time() if self._last_reported_time is None: self._last_reported_step = global_step self._last_reported_time = current_time else: if global_step >= self._every_n_steps + self._last_reported_step: added_steps = global_step - self._last_reported_step elapsed_time = current_time - self._last_reported_time steps_per_sec = added_steps / elapsed_time summary = Summary(value=[Summary.Value( tag=self._summary_tag, simple_value=steps_per_sec)]) self._summary_writer.add_summary(summary, global_step) self._last_reported_step = global_step self._last_reported_time = current_time class NanLossDuringTrainingError(RuntimeError): def __str__(self): return "NaN loss during training." class NanTensorHook(session_run_hook.SessionRunHook): """NaN Loss monitor. Monitors loss and stops training if loss is NaN. Can either fail with exception or just stop training. """ def __init__(self, loss_tensor, fail_on_nan_loss=True): """Initializes NanLoss monitor. Args: loss_tensor: `Tensor`, the loss tensor. fail_on_nan_loss: `bool`, whether to raise exception when loss is NaN. """ self._loss_tensor = loss_tensor self._fail_on_nan_loss = fail_on_nan_loss def before_run(self, run_context): # pylint: disable=unused-argument return SessionRunArgs(self._loss_tensor) def after_run(self, run_context, run_values): if np.isnan(run_values.results): failure_message = "Model diverged with loss = NaN." if self._fail_on_nan_loss: logging.error(failure_message) raise NanLossDuringTrainingError else: logging.warning(failure_message) # We don't raise an error but we request stop without an exception. run_context.request_stop() class SummarySaverHook(session_run_hook.SessionRunHook): """Saves summaries every N steps.""" def __init__(self, save_steps=100, output_dir=None, summary_writer=None, scaffold=None, summary_op=None): """Initializes a `SummarySaver` monitor. Args: save_steps: `int`, save summaries every N steps. See `EveryN`. output_dir: `string`, the directory to save the summaries to. Only used if no `summary_writer` is supplied. summary_writer: `SummaryWriter`. If `None` and an `output_dir` was passed, one will be created accordingly. scaffold: `Scaffold` to get summary_op if it's not provided. summary_op: `Tensor` of type `string`. A serialized `Summary` protocol buffer, as output by TF summary methods like `scalar_summary` or `merge_all_summaries`. """ # TODO(ipolosukhin): Implement every N seconds. self._summary_op = summary_op self._summary_writer = summary_writer if summary_writer is None and output_dir: self._summary_writer = SummaryWriterCache.get(output_dir) self._scaffold = scaffold self._save_steps = save_steps # TODO(mdan): Throw an error if output_dir and summary_writer are None. def begin(self): self._last_saved_step = None self._request_summary = True self._global_step_tensor = contrib_variables.get_global_step() if self._global_step_tensor is None: raise RuntimeError( "Global step should be created to use SummarySaverHook.") def before_run(self, run_context): # pylint: disable=unused-argument requests = {"global_step": self._global_step_tensor} if self._request_summary: if self._summary_op is not None: requests["summary"] = self._summary_op elif self._scaffold.summary_op is not None: requests["summary"] = self._scaffold.summary_op return SessionRunArgs(requests) def after_run(self, run_context, run_values): _ = run_context if not self._summary_writer: return global_step = run_values.results["global_step"] if self._last_saved_step is None: self._summary_writer.add_session_log( SessionLog(status=SessionLog.START), global_step) if self._request_summary: self._last_saved_step = global_step if "summary" in run_values.results: self._summary_writer.add_summary(run_values.results["summary"], global_step) self._request_summary = ( global_step >= self._last_saved_step + self._save_steps - 1) def end(self, session=None): if self._summary_writer: self._summary_writer.flush() def _as_graph_element(obj): """Retrieves Graph element.""" graph = ops.get_default_graph() if not isinstance(obj, six.string_types): if not hasattr(obj, "graph") or obj.graph != graph: raise ValueError("Passed %s should have graph attribute that is equal " "to current graph %s." % (obj, graph)) return obj if ":" in obj: element = graph.as_graph_element(obj) else: element = graph.as_graph_element(obj + ":0") # Check that there is no :1 (e.g. it's single output). try: graph.as_graph_element(obj + ":1") except (KeyError, ValueError): pass else: raise ValueError("Name %s is ambiguous, " "as this `Operation` has multiple outputs " "(at least 2)." % obj) return element
35.992519
89
0.701933
[ "Apache-2.0" ]
Najah-lshanableh/tensorflow
tensorflow/contrib/learn/python/learn/basic_session_run_hooks.py
14,433
Python
import unittest from my_lambdata.assignment1 import WrangledFrame class TestWrangledFrame(unittest.TestCase): def test_add_state_names(self): wf = WrangledFrame({"abbrev": ["CA", "CO", "CT", "DC", "TX"]}) breakpoint() wf.add_state_names() # ensure there is a "name" column self.assertEqual(list(wf.columns), ['abbrev', 'name']) # ensure the values of WF are specific classes/values # (string, "California") self.assertEqual(wf["name"][0], "California") self.assertEqual(wf["abbrev"][0], "CA") if __name__ == '__main__': unittest.main()
27.086957
70
0.627608
[ "MIT" ]
zack-murray/lambdata-zmurray
tests/wrangled_test.py
623
Python
# -*- coding:utf-8 -*- """ 博客系统。 """ import pymysql pymysql.install_as_MySQLdb()
12.142857
28
0.611765
[ "Apache-2.0" ]
nebula-2020/202103
end/nebulablogs/__init__.py
95
Python
# -*- coding: utf-8 -*- import pytest import tempfile from jsonschema import ValidationError from rasa.nlu import training_data from rasa.nlu.convert import convert_training_data from rasa.nlu.extractors.mitie_entity_extractor import MitieEntityExtractor from rasa.nlu.tokenizers.whitespace_tokenizer import WhitespaceTokenizer from rasa.nlu.training_data import TrainingData from rasa.nlu.training_data.formats import MarkdownReader from rasa.nlu.training_data.formats.rasa import validate_rasa_nlu_data from rasa.nlu.training_data.loading import guess_format, UNK, load_data from rasa.nlu.training_data.util import get_file_format import rasa.utils.io as io_utils def test_example_training_data_is_valid(): demo_json = "data/examples/rasa/demo-rasa.json" data = io_utils.read_json_file(demo_json) validate_rasa_nlu_data(data) @pytest.mark.parametrize( "invalid_data", [ {"wrong_top_level": []}, ["this is not a toplevel dict"], { "rasa_nlu_data": { "common_examples": [{"intent": "some example without text"}] } }, { "rasa_nlu_data": { "common_examples": [ { "text": "mytext", "entities": [{"start": "INVALID", "end": 0, "entity": "x"}], } ] } }, ], ) def test_validation_is_throwing_exceptions(invalid_data): with pytest.raises(ValidationError): validate_rasa_nlu_data(invalid_data) def test_luis_data(): td = training_data.load_data("data/examples/luis/demo-restaurants.json") assert not td.is_empty() assert len(td.entity_examples) == 8 assert len(td.intent_examples) == 28 assert len(td.training_examples) == 28 assert td.entity_synonyms == {} assert td.intents == {"affirm", "goodbye", "greet", "inform"} assert td.entities == {"location", "cuisine"} def test_wit_data(): td = training_data.load_data("data/examples/wit/demo-flights.json") assert not td.is_empty() assert len(td.entity_examples) == 4 assert len(td.intent_examples) == 1 assert len(td.training_examples) == 4 assert td.entity_synonyms == {} assert td.intents == {"flight_booking"} assert td.entities == {"location", "datetime"} def test_dialogflow_data(): td = training_data.load_data("data/examples/dialogflow/") assert not td.is_empty() assert len(td.entity_examples) == 5 assert len(td.intent_examples) == 24 assert len(td.training_examples) == 24 assert len(td.lookup_tables) == 2 assert td.intents == {"affirm", "goodbye", "hi", "inform"} assert td.entities == {"cuisine", "location"} non_trivial_synonyms = {k: v for k, v in td.entity_synonyms.items() if k != v} assert non_trivial_synonyms == { "mexico": "mexican", "china": "chinese", "india": "indian", } # The order changes based on different computers hence the grouping assert {td.lookup_tables[0]["name"], td.lookup_tables[1]["name"]} == { "location", "cuisine", } assert { len(td.lookup_tables[0]["elements"]), len(td.lookup_tables[1]["elements"]), } == {4, 6} def test_lookup_table_json(): lookup_fname = "data/test/lookup_tables/plates.txt" td_lookup = training_data.load_data("data/test/lookup_tables/lookup_table.json") assert not td_lookup.is_empty() assert td_lookup.lookup_tables[0]["name"] == "plates" assert td_lookup.lookup_tables[0]["elements"] == lookup_fname assert td_lookup.lookup_tables[1]["name"] == "drinks" assert td_lookup.lookup_tables[1]["elements"] == [ "mojito", "lemonade", "sweet berry wine", "tea", "club mate", ] def test_lookup_table_md(): lookup_fname = "data/test/lookup_tables/plates.txt" td_lookup = training_data.load_data("data/test/lookup_tables/lookup_table.md") assert not td_lookup.is_empty() assert td_lookup.lookup_tables[0]["name"] == "plates" assert td_lookup.lookup_tables[0]["elements"] == lookup_fname assert td_lookup.lookup_tables[1]["name"] == "drinks" assert td_lookup.lookup_tables[1]["elements"] == [ "mojito", "lemonade", "sweet berry wine", "tea", "club mate", ] @pytest.mark.parametrize( "files", [ [ "data/examples/rasa/demo-rasa.json", "data/examples/rasa/demo-rasa-responses.md", ], [ "data/examples/rasa/demo-rasa.md", "data/examples/rasa/demo-rasa-responses.md", ], ], ) def test_demo_data(files): from rasa.importers.utils import training_data_from_paths td = training_data_from_paths(files, language="en") assert td.intents == {"affirm", "greet", "restaurant_search", "goodbye", "chitchat"} assert td.entities == {"location", "cuisine"} assert td.responses == {"I am Mr. Bot", "It's sunny where I live"} assert len(td.training_examples) == 46 assert len(td.intent_examples) == 46 assert len(td.response_examples) == 4 assert len(td.entity_examples) == 11 assert len(td.nlg_stories) == 2 assert td.entity_synonyms == { "Chines": "chinese", "Chinese": "chinese", "chines": "chinese", "vegg": "vegetarian", "veggie": "vegetarian", } assert td.regex_features == [ {"name": "greet", "pattern": r"hey[^\s]*"}, {"name": "zipcode", "pattern": r"[0-9]{5}"}, ] @pytest.mark.parametrize( "filepaths", [["data/examples/rasa/demo-rasa.md", "data/examples/rasa/demo-rasa-responses.md"]], ) def test_train_test_split(filepaths): from rasa.importers.utils import training_data_from_paths td = training_data_from_paths(filepaths, language="en") assert td.intents == {"affirm", "greet", "restaurant_search", "goodbye", "chitchat"} assert td.entities == {"location", "cuisine"} assert len(td.training_examples) == 46 assert len(td.intent_examples) == 46 td_train, td_test = td.train_test_split(train_frac=0.8) assert len(td_train.training_examples) == 35 assert len(td_test.training_examples) == 11 @pytest.mark.parametrize( "files", [ ("data/examples/rasa/demo-rasa.json", "data/test/multiple_files_json"), ("data/examples/rasa/demo-rasa.md", "data/test/multiple_files_markdown"), ], ) def test_data_merging(files): td_reference = training_data.load_data(files[0]) td = training_data.load_data(files[1]) assert len(td.entity_examples) == len(td_reference.entity_examples) assert len(td.intent_examples) == len(td_reference.intent_examples) assert len(td.training_examples) == len(td_reference.training_examples) assert td.intents == td_reference.intents assert td.entities == td_reference.entities assert td.entity_synonyms == td_reference.entity_synonyms assert td.regex_features == td_reference.regex_features def test_markdown_single_sections(): td_regex_only = training_data.load_data( "data/test/markdown_single_sections/regex_only.md" ) assert td_regex_only.regex_features == [{"name": "greet", "pattern": r"hey[^\s]*"}] td_syn_only = training_data.load_data( "data/test/markdown_single_sections/synonyms_only.md" ) assert td_syn_only.entity_synonyms == {"Chines": "chinese", "Chinese": "chinese"} def test_repeated_entities(): data = """ { "rasa_nlu_data": { "common_examples" : [ { "text": "book a table today from 3 to 6 for 3 people", "intent": "unk", "entities": [ { "entity": "description", "start": 35, "end": 36, "value": "3" } ] } ] } }""" with tempfile.NamedTemporaryFile(suffix="_tmp_training_data.json") as f: f.write(data.encode("utf-8")) f.flush() td = training_data.load_data(f.name) assert len(td.entity_examples) == 1 example = td.entity_examples[0] entities = example.get("entities") assert len(entities) == 1 tokens = WhitespaceTokenizer().tokenize(example.text) start, end = MitieEntityExtractor.find_entity(entities[0], example.text, tokens) assert start == 9 assert end == 10 def test_multiword_entities(): data = """ { "rasa_nlu_data": { "common_examples" : [ { "text": "show me flights to New York City", "intent": "unk", "entities": [ { "entity": "destination", "start": 19, "end": 32, "value": "New York City" } ] } ] } }""" with tempfile.NamedTemporaryFile(suffix="_tmp_training_data.json") as f: f.write(data.encode("utf-8")) f.flush() td = training_data.load_data(f.name) assert len(td.entity_examples) == 1 example = td.entity_examples[0] entities = example.get("entities") assert len(entities) == 1 tokens = WhitespaceTokenizer().tokenize(example.text) start, end = MitieEntityExtractor.find_entity(entities[0], example.text, tokens) assert start == 4 assert end == 7 def test_nonascii_entities(): data = """ { "luis_schema_version": "2.0", "utterances" : [ { "text": "I am looking for a ßäæ ?€ö) item", "intent": "unk", "entities": [ { "entity": "description", "startPos": 19, "endPos": 26 } ] } ] }""" with tempfile.NamedTemporaryFile(suffix="_tmp_training_data.json") as f: f.write(data.encode("utf-8")) f.flush() td = training_data.load_data(f.name) assert len(td.entity_examples) == 1 example = td.entity_examples[0] entities = example.get("entities") assert len(entities) == 1 entity = entities[0] assert entity["value"] == "ßäæ ?€ö)" assert entity["start"] == 19 assert entity["end"] == 27 assert entity["entity"] == "description" def test_entities_synonyms(): data = """ { "rasa_nlu_data": { "entity_synonyms": [ { "value": "nyc", "synonyms": ["New York City", "nyc", "the big apple"] } ], "common_examples" : [ { "text": "show me flights to New York City", "intent": "unk", "entities": [ { "entity": "destination", "start": 19, "end": 32, "value": "NYC" } ] }, { "text": "show me flights to nyc", "intent": "unk", "entities": [ { "entity": "destination", "start": 19, "end": 22, "value": "nyc" } ] } ] } }""" with tempfile.NamedTemporaryFile(suffix="_tmp_training_data.json") as f: f.write(data.encode("utf-8")) f.flush() td = training_data.load_data(f.name) assert td.entity_synonyms["New York City"] == "nyc" def cmp_message_list(firsts, seconds): assert len(firsts) == len(seconds), "Message lists have unequal length" def cmp_dict_list(firsts, seconds): if len(firsts) != len(seconds): return False for a in firsts: for idx, b in enumerate(seconds): if hash(a) == hash(b): del seconds[idx] break else: others = ", ".join([e.text for e in seconds]) assert False, "Failed to find message {} in {}".format(a.text, others) return not seconds @pytest.mark.parametrize( "data_file,gold_standard_file,output_format,language", [ ( "data/examples/wit/demo-flights.json", "data/test/wit_converted_to_rasa.json", "json", None, ), ( "data/examples/luis/demo-restaurants.json", "data/test/luis_converted_to_rasa.json", "json", None, ), ( "data/examples/dialogflow/", "data/test/dialogflow_en_converted_to_rasa.json", "json", "en", ), ( "data/examples/dialogflow/", "data/test/dialogflow_es_converted_to_rasa.json", "json", "es", ), ( "data/examples/rasa/demo-rasa.md", "data/test/md_converted_to_json.json", "json", None, ), ( "data/examples/rasa/demo-rasa.json", "data/test/json_converted_to_md.md", "md", None, ), ( "data/test/training_data_containing_special_chars.json", "data/test/json_with_special_chars_convered_to_md.md", "md", None, ), ], ) def test_training_data_conversion( tmpdir, data_file, gold_standard_file, output_format, language ): out_path = tmpdir.join("rasa_nlu_data.json") convert_training_data(data_file, out_path.strpath, output_format, language) td = training_data.load_data(out_path.strpath, language) assert td.entity_examples != [] assert td.intent_examples != [] gold_standard = training_data.load_data(gold_standard_file, language) cmp_message_list(td.entity_examples, gold_standard.entity_examples) cmp_message_list(td.intent_examples, gold_standard.intent_examples) assert td.entity_synonyms == gold_standard.entity_synonyms # converting the converted file back to original # file format and performing the same tests rto_path = tmpdir.join("data_in_original_format.txt") convert_training_data(out_path.strpath, rto_path.strpath, "json", language) rto = training_data.load_data(rto_path.strpath, language) cmp_message_list(gold_standard.entity_examples, rto.entity_examples) cmp_message_list(gold_standard.intent_examples, rto.intent_examples) assert gold_standard.entity_synonyms == rto.entity_synonyms # If the above assert fails - this can be used # to dump to the file and diff using git # with io.open(gold_standard_file) as f: # f.write(td.as_json(indent=2)) def test_url_data_format(): data = """ { "rasa_nlu_data": { "entity_synonyms": [ { "value": "nyc", "synonyms": ["New York City", "nyc", "the big apple"] } ], "common_examples" : [ { "text": "show me flights to New York City", "intent": "unk", "entities": [ { "entity": "destination", "start": 19, "end": 32, "value": "NYC" } ] } ] } }""" fname = io_utils.create_temporary_file( data.encode("utf-8"), suffix="_tmp_training_data.json", mode="w+b" ) data = io_utils.read_json_file(fname) assert data is not None validate_rasa_nlu_data(data) def test_markdown_entity_regex(): r = MarkdownReader() md = """ ## intent:restaurant_search - i'm looking for a place to eat - i'm looking for a place in the [north](loc-direction) of town - show me [chines](cuisine:chinese) restaurants - show me [chines](22_ab-34*3.A:43er*+?df) restaurants """ result = r.reads(md) assert len(result.training_examples) == 4 first = result.training_examples[0] assert first.data == {"intent": "restaurant_search"} assert first.text == "i'm looking for a place to eat" second = result.training_examples[1] assert second.data == { "intent": "restaurant_search", "entities": [ {"start": 31, "end": 36, "value": "north", "entity": "loc-direction"} ], } assert second.text == "i'm looking for a place in the north of town" third = result.training_examples[2] assert third.data == { "intent": "restaurant_search", "entities": [{"start": 8, "end": 14, "value": "chinese", "entity": "cuisine"}], } assert third.text == "show me chines restaurants" fourth = result.training_examples[3] assert fourth.data == { "intent": "restaurant_search", "entities": [ {"start": 8, "end": 14, "value": "43er*+?df", "entity": "22_ab-34*3.A"} ], } assert fourth.text == "show me chines restaurants" def test_get_file_format(): fformat = get_file_format("data/examples/luis/demo-restaurants.json") assert fformat == "json" fformat = get_file_format("data/examples") assert fformat == "json" fformat = get_file_format("examples/restaurantbot/data/nlu.md") assert fformat == "md" with pytest.raises(AttributeError): get_file_format("path-does-not-exists") with pytest.raises(AttributeError): get_file_format(None) def test_guess_format_from_non_existing_file_path(): assert guess_format("not existing path") == UNK def test_load_data_from_non_existing_file(): with pytest.raises(ValueError): load_data("some path") def test_is_empty(): assert TrainingData().is_empty() def test_markdown_empty_section(): data = training_data.load_data( "data/test/markdown_single_sections/empty_section.md" ) assert data.regex_features == [{"name": "greet", "pattern": r"hey[^\s]*"}] assert not data.entity_synonyms assert len(data.lookup_tables) == 1 assert data.lookup_tables[0]["name"] == "chinese" assert "Chinese" in data.lookup_tables[0]["elements"] assert "Chines" in data.lookup_tables[0]["elements"] def test_markdown_not_existing_section(): with pytest.raises(ValueError): training_data.load_data( "data/test/markdown_single_sections/not_existing_section.md" )
30.249578
88
0.606088
[ "Apache-2.0" ]
AppliedSoul/rasa
tests/nlu/base/test_training_data.py
17,950
Python
# 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 SasDefinitionCreateParameters(Model): """The SAS definition create parameters. All required parameters must be populated in order to send to Azure. :param template_uri: Required. The SAS definition token template signed with an arbitrary key. Tokens created according to the SAS definition will have the same properties as the template. :type template_uri: str :param sas_type: Required. The type of SAS token the SAS definition will create. Possible values include: 'account', 'service' :type sas_type: str or ~storage.models.SasTokenType :param validity_period: Required. The validity period of SAS tokens created according to the SAS definition. :type validity_period: str :param sas_definition_attributes: The attributes of the SAS definition. :type sas_definition_attributes: ~storage.models.SasDefinitionAttributes :param tags: Application specific metadata in the form of key-value pairs. :type tags: dict[str, str] """ _validation = { 'template_uri': {'required': True}, 'sas_type': {'required': True}, 'validity_period': {'required': True}, } _attribute_map = { 'template_uri': {'key': 'templateUri', 'type': 'str'}, 'sas_type': {'key': 'sasType', 'type': 'str'}, 'validity_period': {'key': 'validityPeriod', 'type': 'str'}, 'sas_definition_attributes': {'key': 'attributes', 'type': 'SasDefinitionAttributes'}, 'tags': {'key': 'tags', 'type': '{str}'}, } def __init__(self, **kwargs): super(SasDefinitionCreateParameters, self).__init__(**kwargs) self.template_uri = kwargs.get('template_uri', None) self.sas_type = kwargs.get('sas_type', None) self.validity_period = kwargs.get('validity_period', None) self.sas_definition_attributes = kwargs.get('sas_definition_attributes', None) self.tags = kwargs.get('tags', None)
43.175439
94
0.650549
[ "MIT" ]
mccoyp/azure-keyvault-7.3-preview
sdk/keyvault/azure-keyvault/azure/keyvault/v7_3_preview/models/sas_definition_create_parameters.py
2,461
Python
import ocdskingfisherprocess.cli.commands.base import ocdskingfisherprocess.database from ocdskingfisherprocess.transform import TRANSFORM_TYPE_UPGRADE_1_0_TO_1_1 class NewTransformUpgrade10To11CLICommand(ocdskingfisherprocess.cli.commands.base.CLICommand): command = 'new-transform-upgrade-1-0-to-1-1' def configure_subparser(self, subparser): self.configure_subparser_for_selecting_existing_collection(subparser) def run_command(self, args): self.run_command_for_selecting_existing_collection(args) if self.collection.deleted_at: print("That collection is deleted!") return id = self.database.get_collection_id( self.collection.source_id, self.collection.data_version, self.collection.sample, transform_from_collection_id=self.collection.database_id, transform_type=TRANSFORM_TYPE_UPGRADE_1_0_TO_1_1) if id: print("Already exists! The ID is {}".format(id)) return id = self.database.get_or_create_collection_id(self.collection.source_id, self.collection.data_version, self.collection.sample, transform_from_collection_id=self.collection.database_id, transform_type=TRANSFORM_TYPE_UPGRADE_1_0_TO_1_1) print("Created! The ID is {}".format(id)) print("Now run transform-collection with that ID.")
43.459459
112
0.636816
[ "BSD-3-Clause" ]
matiasSanabria/kingfisher-process
ocdskingfisherprocess/cli/commands/new_transform_upgrade_1_0_to_1_1.py
1,608
Python
# 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/. from iris.test_case import * class Test(BaseTest): def __init__(self, app): BaseTest.__init__(self, app) self.meta = 'This is a test for checking private browsing navigation' def run(self): url = 'https://www.google.com/?hl=EN' private_browsing_image = 'private_browsing.png' google_search_image = 'google_search.png' # check if incognito mode works new_private_window() expected_1 = exists(private_browsing_image, 10) assert_true(self, expected_1, 'Find private browsing image') # check basic_url in incognito mode navigate(url) expected_2 = exists(google_search_image, 10) assert_true(self, expected_2, 'Find google search image')
30.774194
77
0.677149
[ "MPL-2.0" ]
davehunt/iris
iris/tests/experiments/private_browsing_mode.py
954
Python
from flask import Flask, request, abort from linebot import ( LineBotApi, WebhookHandler ) from linebot.exceptions import ( InvalidSignatureError ) from linebot.models import * app = Flask(__name__) # LINE BOT info line_bot_api = LineBotApi('QCynFfsDk7My1YN72sVQyvk6ArYkD2TUQW/pUxUQqllnGFNcqjZ8tKC+qMcVa2u4Lg1WmdUVLcS124tweaXtcVWLmK/thFH1NFUZL/Olev6ugLeKG4VUVd0ee8VUUgnrqqCZD+ZBpD6j61TRW2eJEgdB04t89/1O/w1cDnyilFU=') handler = WebhookHandler('f3b5d7b57ef1f4d1277aecd7f045db3d') @app.route("/callback", methods=['POST']) def callback(): signature = request.headers['X-Line-Signature'] body = request.get_data(as_text=True) app.logger.info("Request body: " + body) print(body) try: handler.handle(body, signature) except InvalidSignatureError: abort(400) return 'OK' # Message event @handler.add(MessageEvent) def handle_message(event): message_type = event.message.type user_id = event.source.user_id reply_token = event.reply_token message = event.message.text line_bot_api.reply_message(reply_token, TextSendMessage(text = message)) import os if __name__ == "__main__": port = int(os.environ.get('PORT', 80)) app.run(host='0.0.0.0', port=port)
30.725
201
0.746949
[ "MIT" ]
tingyo123/IoT_Project
Final_Project/hx711py/lineBotTest.py
1,229
Python
#!/usr/bin/env python3 # still in development # import asyncio import websockets import json import requests eventsAPIPath = '/api/v1/events' localServerIP = '0.0.0.0' localServerAPIPort = '8000' localServerWSPort = '8000' localServerPath = '/sealog-server' localToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjU5ODFmMTY3MjEyYjM0OGFlZDdmYTlmNSIsInNjb3BlIjpbImFkbWluIiwiZXZlbnRfbWFuYWdlciIsImV2ZW50X2xvZ2dlciIsImV2ZW50X3dhdGNoZXIiXSwiaWF0IjoxNTI1MDE0NDE3fQ.D8ja66bnLxJ3bsJlaKRtOquu8XbibjNCyFxJpI7vafc' localClientWSID = 'localSealogReceive' remoteServerIP = '162.243.201.175' remoteServerAPIPort = '80' remoteServerWSPort = '8000' remoteServerPath = '/sealog-server' remoteToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjU5ODFmMTY3MjEyYjM0OGFlZDdmYTlmNSIsInNjb3BlIjpbImFkbWluIiwiZXZlbnRfbWFuYWdlciIsImV2ZW50X2xvZ2dlciIsImV2ZW50X3dhdGNoZXIiXSwiaWF0IjoxNTI1MDEzNTUxfQ.8X-fBRUHdrwtkTLcOFAsW-vvvqCzmkZKM2gQgHNkBKk" remoteClientWSID = 'remoteSealogReceive' hello = { 'type': 'hello', 'id': remoteClientWSID, 'auth': { 'headers': { 'authorization': remoteToken } }, 'version': '2', 'subs': ['/ws/status/newEvents'] } ping = { 'type':'ping', 'id':remoteClientWSID } localHeaders = {'authorization': localToken} remoteHeaders = {'authorization': remoteToken} async def eventlog(): try: async with websockets.connect('ws://' + remoteServerIP + ':' + remoteServerWSPort) as websocket: await websocket.send(json.dumps(hello)) while(True): event = await websocket.recv() eventObj = json.loads(event) print("eventObj:", eventObj) if eventObj['type'] and eventObj['type'] == 'ping': await websocket.send(json.dumps(ping)) elif eventObj['type'] and eventObj['type'] == 'pub': r = requests.post('http://' + localServerIP + ':' + localServerAPIPort + localServerPath + eventsAPIPath, headers=localHeaders, data = json.dumps(eventObj['message'])) print(r.text) ### end of repeat except Exception as error: print(error) asyncio.get_event_loop().run_until_complete(eventlog())
31.347222
251
0.692955
[ "MIT" ]
OceanDataTools/sealog-server
misc/sealog_repeater_receive.py
2,257
Python
PAYLOAD_BITS_120 = '111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111' KEY_BITS_192 = '010101010101010101010101011110100000010111101010101010101000010101110101010101010101010101010101010101010101010100001011111010101010101010101010101010101010101101011111010101000100010010101010' ZEROS_64 = '0000000000000000000000000000000000000000000000000000000000000000' PAYLOAD_RANDOM_64 = '1010101001001101010111111000101010010010110101010001101010010101'
129
209
0.955426
[ "MIT" ]
bejohi/StegoSources
cp1_code/test_constants.py
516
Python
""" https://leetcode.com/problems/powerful-integers/ Given two positive integers x and y, an integer is powerful if it is equal to x^i + y^j for some integers i >= 0 and j >= 0. Return a list of all powerful integers that have value less than or equal to bound. You may return the answer in any order. In your answer, each value should occur at most once. Example 1: Input: x = 2, y = 3, bound = 10 Output: [2,3,4,5,7,9,10] Explanation: 2 = 2^0 + 3^0 3 = 2^1 + 3^0 4 = 2^0 + 3^1 5 = 2^1 + 3^1 7 = 2^2 + 3^1 9 = 2^3 + 3^0 10 = 2^0 + 3^2 Example 2: Input: x = 3, y = 5, bound = 15 Output: [2,4,6,8,10,14] Note: 1 <= x <= 100 1 <= y <= 100 0 <= bound <= 10^6 """ # time complexity: O(n), space complexity: O(n^0.5) class Solution: def powerfulIntegers(self, x: int, y: int, bound: int) -> List[int]: xlist = [1] ylist = [1] i = 1 while x**i <= bound and x > 1: xlist.append(x**i) i += 1 i = 1 while y**i <= bound and y > 1: ylist.append(y**i) i += 1 return list(set(x+y for x in xlist for y in ylist if x+y <= bound))
22.7
124
0.557709
[ "Apache-2.0" ]
Davidxswang/leetcode
easy/970-Powerful Integers.py
1,135
Python
class RenderNodeAction(Enum,IComparable,IFormattable,IConvertible): """ Enumerated actions for processing a render node during custom export. enum RenderNodeAction,values: Proceed (0),Skip (1) """ def __eq__(self,*args): """ x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """ pass def __format__(self,*args): """ __format__(formattable: IFormattable,format: str) -> str """ pass def __ge__(self,*args): pass def __gt__(self,*args): pass def __init__(self,*args): """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """ pass def __le__(self,*args): pass def __lt__(self,*args): pass def __ne__(self,*args): pass def __reduce_ex__(self,*args): pass def __str__(self,*args): pass Proceed=None Skip=None value__=None
28.470588
215
0.667355
[ "MIT" ]
denfromufa/ironpython-stubs
stubs.min/Autodesk/Revit/DB/__init___parts/RenderNodeAction.py
968
Python
import numpy as np import torch from dataclasses import dataclass from typing import List from jiant.tasks.core import ( BaseExample, BaseTokenizedExample, BaseDataRow, BatchMixin, GlueMixin, Task, TaskTypes, ) from jiant.tasks.lib.templates.shared import double_sentence_featurize, labels_to_bimap from jiant.utils.python.io import read_jsonl @dataclass class Example(BaseExample): guid: str input_premise: str input_hypothesis: str label: str def tokenize(self, tokenizer): return TokenizedExample( guid=self.guid, input_premise=tokenizer.tokenize(self.input_premise), input_hypothesis=tokenizer.tokenize(self.input_hypothesis), label_id=WnliTask.LABEL_TO_ID[self.label], ) @dataclass class TokenizedExample(BaseTokenizedExample): guid: str input_premise: List input_hypothesis: List label_id: int def featurize(self, tokenizer, feat_spec): return double_sentence_featurize( guid=self.guid, input_tokens_a=self.input_premise, input_tokens_b=self.input_hypothesis, label_id=self.label_id, tokenizer=tokenizer, feat_spec=feat_spec, data_row_class=DataRow, ) @dataclass class DataRow(BaseDataRow): guid: str input_ids: np.ndarray input_mask: np.ndarray segment_ids: np.ndarray label_id: int tokens: list @dataclass class Batch(BatchMixin): input_ids: torch.LongTensor input_mask: torch.LongTensor segment_ids: torch.LongTensor label_id: torch.LongTensor tokens: list class WnliTask(GlueMixin, Task): Example = Example TokenizedExample = Example DataRow = DataRow Batch = Batch TASK_TYPE = TaskTypes.CLASSIFICATION LABELS = ["0", "1"] LABEL_TO_ID, ID_TO_LABEL = labels_to_bimap(LABELS) def get_train_examples(self): return self._create_examples(lines=read_jsonl(self.train_path), set_type="train") def get_val_examples(self): return self._create_examples(lines=read_jsonl(self.val_path), set_type="val") def get_test_examples(self): return self._create_examples(lines=read_jsonl(self.test_path), set_type="test") @classmethod def _create_examples(cls, lines, set_type): examples = [] for (i, line) in enumerate(lines): examples.append( Example( # NOTE: get_glue_preds() is dependent on this guid format. guid="%s-%s" % (set_type, i), input_premise=line["premise"], input_hypothesis=line["hypothesis"], label=line["label"] if set_type != "test" else cls.LABELS[-1], ) ) return examples
26.688679
89
0.655002
[ "MIT" ]
HonoMi/jiant
jiant/tasks/lib/wnli.py
2,829
Python
# Copyright 2015 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS-IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """External task balancer. Overall architecture is: 1. Users interact with clients. 2. Clients make requests against the frontend's REST API. 3. The FE makes a REST call against a worker or worker pool identified by gcb_external_task_balancer_worker_url. The FE provisions a unique token, generates a Task instance, and dispatches a REST request to the worker or worker pool. 4. The worker or worker pool exposes a REST API for use by the FE. Worker responses contain the name of the worker so the FE can poll a specific worker for results using the (ticket, name) combination. Workers are in charge both of doing work and of cleaning up their results. Clients do not talk to workers directly. To enable, set up a pool of workers behind a single URL. For example, this might be a set of machines behind a balancer on GCE or an AWS ELB. Next, set gcb_external_task_balancer_rest_enabled to True and set gcb_external_task_balancer_worker_url to the URL of your worker pool. Secure communication if desired, and write a client against the REST API this module exposes. This implementation has the following big limitations: 1. It is insecure. Currently there is no token exchange/validation at the API level, so anyone who gets a ticket (for example, by listening to HTTP traffic between clients and the FE) can issue API calls. 2. There is no XSSI/XSRF protection. Note that exposed endpoints will 404 by default because gcb_external_task_balancer_rest_enabled is False, so the behavior without overrides does *not* expose unprotected REST endpoints. 3. Old task items hang around forever. Could implement garbage collection cron to remove them past a TTL. 4. The REST api is missing ability to mark a single task for deletion and to fetch a paginated list of results (without their payloads) for a given user_id. Open issue: we do not expose the notion of a project in the REST API, but we have it in the workers. Should we expose it to allow filtering at the API level? 5. Add support for one balancer handling multiple pools of workers, not just one. 6. Manager.mark* methods don't all check that the requested status transition is valid. This means buggy handlers/workers/clients could cause invalid status transitions. Fix is to have the Manager throw TransitionError in those cases and modify the handlers to 400/500. TODO(johncox): add URL of sample worker implementation once it's finished. """ __author__ = [ '[email protected] (John Cox)', ] import logging import urllib from controllers import utils from models import config from models import custom_modules from models import entities from models import transforms from google.appengine.api import urlfetch from google.appengine.ext import db _DISABLE_CACHING_HEADERS = { 'Cache-Control': 'max-age=0, must-revalidate', 'Pragma': 'no-cache', } _PAYLOAD = 'payload' _TICKET = 'ticket' _PROJECT_NAME = 'project' _REST_URL_BASE = '/rest/balancer/v1' _REST_URL_PROJECT = _REST_URL_BASE + '/project' _REST_URL_TASK = _REST_URL_BASE _STATUS = 'status' _USER_ID = 'user_id' _WORKER_DEADLINE_SECONDS = 5 _WORKER_ID = 'worker_id' _WORKER_LOCKED = 'Worker locked' _WORKER_LOCKED_MAX_RETRIES = 3 _LOG = logging.getLogger('modules.balancer.balancer') logging.basicConfig() EXTERNAL_TASK_BALANCER_REST_ENABLED = config.ConfigProperty( 'gcb_external_task_balancer_rest_enabled', bool, ('Whether or not to enable the REST endpoints for the external task ' 'balancer module. You must also set the external task balancer URL ' 'to use this feature.'), default_value=False, label='Enable task balancer REST endpoints') EXTERNAL_TASK_BALANCER_WORKER_URL = config.ConfigProperty( 'gcb_external_task_balancer_worker_url', str, 'URL for the worker pool used by the external task balancer module.', default_value='', label='External task balancer worker URL') class Error(Exception): """Base error class.""" class NotFoundError(Exception): """Raised when an op that needs an entity is run with a missing entity.""" class TransitionError(Exception): """Raised when an op attempts an invalid transition on a task.""" def _from_json(json_str): """Turns json -> object (or None if json cannot be parsed).""" try: return transforms.loads(json_str) except: # Deliberately catching everything. pylint: disable=bare-except return None class Manager(object): """DAO for external tasks.""" # Treating access as module-protected. pylint: disable=protected-access @classmethod def create(cls, user_id=None): """Creates task and returns ticket string.""" task = _ExternalTask(status=_ExternalTask.CREATED, user_id=user_id) return _ExternalTask.get_ticket_by_key(db.put(task)) @classmethod def get(cls, ticket): """Gets task for ticket (or None if no matching task).""" external_task = db.get(_ExternalTask.get_key_by_ticket(ticket)) if not external_task: return None return Task._from_external_task(external_task) @classmethod def list(cls, user_id): """Returns list of Task matching user_id, ordered by create date.""" return [Task._from_external_task(et) for et in sorted( _ExternalTask.all().filter( '%s =' % _ExternalTask.user_id.name, user_id ).fetch(1000), key=lambda task: task.create_date)] @classmethod @db.transactional def mark_deleted(cls, ticket): task = cls._get_or_raise_not_found_error(ticket) task.status = _ExternalTask.DELETED db.put(task) @classmethod @db.transactional def mark_done(cls, ticket, status, result): if status not in _ExternalTask._TERMINAL_STATUSES: raise TransitionError( 'mark_done called with non-terminal status ' + status) task = cls._get_or_raise_not_found_error(ticket) task.result = result task.status = status db.put(task) @classmethod @db.transactional def mark_failed(cls, ticket): task = cls._get_or_raise_not_found_error(ticket) task.status = _ExternalTask.FAILED db.put(task) @classmethod @db.transactional def mark_running(cls, ticket, worker_id): task = cls._get_or_raise_not_found_error(ticket) task.status = _ExternalTask.RUNNING task.worker_id = worker_id db.put(task) @classmethod def _delete(cls, ticket): key = _ExternalTask.get_key_by_ticket(ticket) db.delete(key) @classmethod def _get_or_raise_not_found_error(cls, ticket): key = _ExternalTask.get_key_by_ticket(ticket) task = db.get(key) if not task: raise NotFoundError return task class Task(object): """DTO for external tasks.""" def __init__( self, change_date, create_date, result, status, ticket, user_id, worker_id): self.change_date = change_date self.create_date = create_date self.result = result self.status = status self.ticket = ticket self.user_id = user_id self.worker_id = worker_id @classmethod def _from_external_task(cls, external_task): return cls( external_task.change_date, external_task.create_date, external_task.result, external_task.status, external_task.get_ticket(), external_task.user_id, external_task.worker_id) def is_done(self): return _ExternalTask.is_status_terminal(self.status) def for_json(self): return { 'change_date': self.change_date.strftime( transforms.ISO_8601_DATETIME_FORMAT), 'create_date': self.create_date.strftime( transforms.ISO_8601_DATETIME_FORMAT), 'result': self.result, 'status': self.status, 'ticket': self.ticket, 'user_id': self.user_id, 'worker_id': self.worker_id, } def __eq__(self, other): return ( isinstance(other, Task) and self.change_date == other.change_date and self.create_date == other.create_date and self.result == other.result and self.status == other.status and self.ticket == other.ticket and self.user_id == other.user_id and self.worker_id == other.worker_id) def __ne__(self, other): return not self.__eq__(other) def __str__(self): return ( 'Task - change_date: %(change_date)s, ' 'create_date: %(create_date)s, result: %(result)s, ' 'status: %(status)s, ticket: %(ticket)s, user_id: %(user_id)s, ' 'worker_id: %(worker_id)s' % self.to_dict()) class _ExternalTask(entities.BaseEntity): """Storage for external tasks.""" # States a task may be in. COMPLETE = 'complete' # Done running and in known success state. CREATED = 'created' # Datastore entity created, but task not yet running. DELETED = 'deleted' # Marked for deletion; could be deleted later. FAILED = 'failed' # Done running and in known failure state. RUNNING = 'running' # Currently running on a worker. _PENDING_STATUSES = frozenset([ CREATED, RUNNING, ]) _TERMINAL_STATUSES = frozenset([ COMPLETE, DELETED, FAILED, ]) STATUSES = _PENDING_STATUSES.union(_TERMINAL_STATUSES) # When the task was last edited. change_date = db.DateTimeProperty(required=True, auto_now=True) # When the task was created. create_date = db.DateTimeProperty(required=True, auto_now_add=True) # Output of the task in JSON. result = db.TextProperty() # Last observed status of the task. Can be inaccurate: for example, if a # user creates a new task but navigates away before the task completes and # their client never fetches the task when it's done, we'll still show it # running. status = db.StringProperty(required=True, choices=STATUSES) # Optional identifier for the user who owns the task. We impose no # restrictions beyond the identifier being a string <= 500B, per datastore. user_id = db.StringProperty() # Identifier for the worker. worker_id = db.StringProperty() @classmethod def get_key_by_ticket(cls, ticket_str): try: return db.Key(encoded=ticket_str) except: raise ValueError( 'Cannot make _ExternalTask key from ticket value: %s' % ( ticket_str)) @classmethod def get_ticket_by_key(cls, key): return str(key) @classmethod def is_status_terminal(cls, status): return status in cls._TERMINAL_STATUSES def get_ticket(self): """Returns string identifier for the task; raises NotSavedError.""" return self.get_ticket_by_key(self.key()) class _Operation(object): """Base class for wire operation payloads.""" @classmethod def from_str(cls, raw_str): return cls._from_json(transforms.loads(raw_str)) @classmethod def _from_json(cls, parsed): # Parse and validate raw input, raising ValueError if necessary. raise NotImplementedError def ready(self): """True iff the operation has all data it needs to be issued.""" raise NotImplementedError def to_json(self): return transforms.dumps(self._to_dict()) def to_url(self): return urllib.quote_plus(self.to_json()) def update(self, updates_dict): for k, v in updates_dict.iteritems(): if not hasattr(self, k): raise ValueError('Cannot set name ' + k) setattr(self, k, v) def _to_dict(self): raise NotImplementedError class _CreateTaskOperation(_Operation): def __init__(self, payload, ticket, user_id): self.payload = payload self.ticket = ticket self.user_id = user_id @classmethod def _from_json(cls, parsed): return cls(parsed, None, parsed.get(_USER_ID)) def ready(self): return self.payload is not None and self.ticket is not None def _to_dict(self): return { _PAYLOAD: self.payload, _TICKET: self.ticket, _USER_ID: self.user_id, } class _GetProjectOperation(_Operation): def __init__(self, payload): self.payload = payload @classmethod def _from_json(cls, parsed): return cls(parsed) def ready(self): return self.payload is not None def _to_dict(self): return {_PAYLOAD: self.payload} class _GetTaskOperation(_Operation): def __init__(self, payload, ticket, worker_id): self.payload = payload self.ticket = ticket self.worker_id = worker_id @classmethod def _from_json(cls, parsed): ticket = parsed.get(_TICKET) if not ticket: raise ValueError('%s not set' % _TICKET) return cls(parsed, ticket, parsed.get(_WORKER_ID)) def ready(self): return ( self.payload is not None and self.ticket is not None and self.worker_id is not None) def _to_dict(self): return { _PAYLOAD: self.payload, _TICKET: self.ticket, _WORKER_ID: self.worker_id, } class _WorkerPool(object): """Interface for the pool of machines that do background work.""" @classmethod def _check_response(cls, response): return response.has_key(_PAYLOAD) @classmethod def _do_fetch(cls, url, method, operation): try: response = urlfetch.fetch( cls._get_url(url, method, operation), deadline=_WORKER_DEADLINE_SECONDS, headers=_DISABLE_CACHING_HEADERS, method=method, payload=cls._get_request_body(method, operation)) return ( response.status_code, cls._transform_response(response)) except urlfetch.DownloadError as e: # 4xx, 5xx, timeouts. _LOG.error('Unable to dispatch request to pool; error: %s', e) return 500, {_PAYLOAD: 'Unable to dispatch request'} @classmethod def _get_base_url(cls, worker_id=None): base = ( worker_id if worker_id is not None else EXTERNAL_TASK_BALANCER_WORKER_URL.value) return base + '/rest/v1' @classmethod def _get_create_task_url(cls): return cls._get_base_url() @classmethod def _get_get_project_url(cls): return cls._get_base_url() + '/project' @classmethod def _get_get_task_url(cls, worker_id): return cls._get_base_url(worker_id=worker_id) @classmethod def _get_request_body(cls, method, operation): if method == 'GET': return None return operation.to_json() @classmethod def _get_url(cls, url, method, operation): if method == 'GET': return '%s?request=%s' % (url, operation.to_url()) return url @classmethod def _transform_response(cls, response): """Transforms worker success/error responses into a standard format.""" try: parsed = transforms.loads(response.content) if not cls._check_response(parsed): raise ValueError return {_PAYLOAD: parsed[_PAYLOAD]} except: # Catch everything on purpose. pylint: disable=bare-except _LOG.error( 'Unable to parse worker response: ' + response.content) return {_PAYLOAD: 'Received invalid response'} @classmethod def create_task(cls, operation): return cls._do_fetch(cls._get_create_task_url(), 'POST', operation) @classmethod def get_project(cls, operation): return cls._do_fetch(cls._get_get_project_url(), 'GET', operation) @classmethod def get_task(cls, operation): return cls._do_fetch( cls._get_get_task_url(operation.worker_id), 'GET', operation) class _BaseRestHandler(utils.BaseRESTHandler): def _send_json_response(self, code, response): self.response.headers['Content-Disposition'] = 'attachment' self.response.headers['Content-Type'] = ( 'application/javascript; charset=utf-8') self.response.headers['X-Content-Type-Options'] = 'nosniff' self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.status_code = code self.response.write(transforms.dumps(response)) def _check_config_or_send_error(self): if not EXTERNAL_TASK_BALANCER_REST_ENABLED.value: self._send_json_response(404, 'Not found.') return False elif not EXTERNAL_TASK_BALANCER_WORKER_URL.value: self._send_json_response(500, 'No worker pool found.') return False return True class _ProjectRestHandler(_BaseRestHandler): def get(self): configured = self._check_config_or_send_error() if not configured: return try: op = _GetProjectOperation.from_str(self.request.get('request')) except ValueError: self._send_json_response(400, 'Bad request') return self._send_json_response(*_WorkerPool.get_project(op)) class _TaskRestHandler(_BaseRestHandler): def _get_payload(self, response): return response.get(_PAYLOAD) def _get_status(self, response): return self._get_payload(response).get(_STATUS) def _get_task_payload(self, response): return response.get(_PAYLOAD).get(_PAYLOAD) def _get_ticket(self, response): return self._get_payload(response).get(_TICKET) def _get_worker_id(self, response): return self._get_payload(response).get(_WORKER_ID) def _retry_create_task(self, response, op): tries = 0 while tries < _WORKER_LOCKED_MAX_RETRIES: tries += 1 _LOG.info('Worker locked; retrying (tries: %s)', tries) code, response = _WorkerPool.create_task(op) if not self._worker_locked(response): return code, response return code, {_PAYLOAD: _WORKER_LOCKED} def _worker_locked(self, response): return response.get(_PAYLOAD) == _WORKER_LOCKED def get(self): configured = self._check_config_or_send_error() if not configured: return try: op = _GetTaskOperation.from_str(self.request.get('request')) except: # pylint: disable=bare-except self._send_json_response(400, 'Bad request') return task = None try: task = Manager.get(op.ticket) except ValueError: pass # Invalid ticket; handle as 404. if not task: self._send_json_response( 404, 'Task not found for ticket %s' % op.ticket) return if task.is_done(): self._send_json_response(200, task.for_json()) return op.update({_WORKER_ID: task.worker_id}) if not op.ready(): # If the operation cannot be issued now, the most likely cause is # that a past response from a worker contained insufficient data to # dispatch requests to that worker (for example, it might not have) # set the worker_id). We cannot recover; all we can do is signal # likely programmer error. self._send_json_response( 500, 'Unable to compose request for worker') return code, response = _WorkerPool.get_task(op) if code != 200: self._send_json_response(code, response) return status = self._get_status(response) if status is None: self._send_json_response(500, 'Worker sent partial response') return elif _ExternalTask.is_status_terminal(status): try: payload = self._get_task_payload(response) Manager.mark_done(op.ticket, status, payload) except: # Catch everything. pylint: disable=bare-except # TODO(johncox): could differentiate here and transition to a # failed state when the payload is too big so we don't force # unnecessary refetches against workers. self._send_json_response( 500, 'Invalid worker status or payload too big') return self._send_json_response(*_WorkerPool.get_task(op)) def post(self): configured = self._check_config_or_send_error() if not configured: return try: op = _CreateTaskOperation.from_str(self.request.get('request')) except: # pylint: disable=bare-except self._send_json_response(400, 'Bad request') return # Must allocate ticket at storage level for wire ops against worker, so # we cannot create the task in one datastore call. ticket = Manager.create(user_id=op.user_id) op.update({_TICKET: ticket}) if not op.ready(): self._send_json_response( 500, 'Unable to compose request for worker') return code, response = _WorkerPool.create_task(op) if self._worker_locked(response): code, response = self._retry_create_task(response, op) if code != 200: Manager.mark_failed(ticket) self._send_json_response(500, self._get_payload(response)) return request_failed = code != 200 ticket_mismatch = self._get_ticket(response) != ticket if request_failed or ticket_mismatch: response = 'Ticket mismatch' if ticket_mismatch else 'Worker failed' Manager.mark_failed(ticket) self._send_json_response(500, response) else: # Worker response indicates success. Manager.mark_running(ticket, self._get_worker_id(response)) self._send_json_response(code, response) custom_module = None def register_module(): global custom_module # pylint: disable=global-statement global_handlers = [ (_REST_URL_TASK, _TaskRestHandler), (_REST_URL_PROJECT, _ProjectRestHandler), ] namespaced_handlers = [] custom_module = custom_modules.Module( 'External Task Balancer', 'External Task Balancer', global_handlers, namespaced_handlers) return custom_module
33.253923
80
0.658616
[ "Apache-2.0" ]
ehiller/CourseBuilderV19-TeacherDashboard
modules/balancer/balancer.py
23,311
Python
""" CLI tests """ from tso.tsocli import __main__ as tsocli import pytest from unittest.mock import patch, MagicMock, mock_open mock_configurqation = "{}" class TestCli: def test_cli_should_exit_with_no_args(self): with pytest.raises(SystemExit) as pytest_wrapped_e: tsocli.main([]) assert pytest_wrapped_e.type == SystemExit assert pytest_wrapped_e.value.code == 1 def test_cli_should_exit_with_only_one_arg(self): with pytest.raises(SystemExit) as pytest_wrapped_e_pseudo_name: tsocli.main(['s']) with pytest.raises(SystemExit) as pytest_wrapped_e_full_name: tsocli.main(['schedule']) # Both Exceptions should be the same assert pytest_wrapped_e_pseudo_name.type == pytest_wrapped_e_full_name.type assert pytest_wrapped_e_pseudo_name.value.code == pytest_wrapped_e_full_name.value.code # The exceptions should be a System Exit assert pytest_wrapped_e_pseudo_name.type == SystemExit assert pytest_wrapped_e_pseudo_name.value.code == 1 @patch('configuration.configuration_parser.parse', return_value=mock_configurqation) @patch('tso.tsocli.command.cli_pipeline') def test_cli_should_call_pipeline_when_successful(self, mock_pipeline, mock_config_parser): tsocli.main([ 'schedule', '--start-date-time', '2019-03-01 19:00', '--end-date-time', '2019-03-12 19:00', '--export-to-file', '--export-to-browser' ]) assert mock_pipeline.called @patch('configuration.configuration_parser.parse', return_value=mock_configurqation) @patch('tso.tsocli.command.cli_pipeline') def test_cli_should_have_default_date_time_values(self, mock_pipeline, mock_config_parser): tsocli.main([ 'schedule', '--export-to-file' ]) assert mock_pipeline.call_args.start_date_time assert mock_pipeline.call_args.end_date_time
30.787879
95
0.683071
[ "MIT" ]
elijah-ward/TSO
src/tso/tsocli/tests/test_cli.py
2,032
Python
# # 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 datetime import unittest from unittest import mock from airflow.models.dag import DAG from airflow.providers.microsoft.azure.transfers.local_to_wasb import LocalFilesystemToWasbOperator class TestLocalFilesystemToWasbOperator(unittest.TestCase): _config = { 'file_path': 'file', 'container_name': 'container', 'blob_name': 'blob', 'wasb_conn_id': 'wasb_default', 'retries': 3, } def setUp(self): args = {'owner': 'airflow', 'start_date': datetime.datetime(2017, 1, 1)} self.dag = DAG('test_dag_id', default_args=args) def test_init(self): operator = LocalFilesystemToWasbOperator(task_id='wasb_operator_1', dag=self.dag, **self._config) assert operator.file_path == self._config['file_path'] assert operator.container_name == self._config['container_name'] assert operator.blob_name == self._config['blob_name'] assert operator.wasb_conn_id == self._config['wasb_conn_id'] assert operator.load_options == {} assert operator.retries == self._config['retries'] operator = LocalFilesystemToWasbOperator( task_id='wasb_operator_2', dag=self.dag, load_options={'timeout': 2}, **self._config ) assert operator.load_options == {'timeout': 2} @mock.patch('airflow.providers.microsoft.azure.transfers.local_to_wasb.WasbHook', autospec=True) def test_execute(self, mock_hook): mock_instance = mock_hook.return_value operator = LocalFilesystemToWasbOperator( task_id='wasb_sensor', dag=self.dag, load_options={'timeout': 2}, **self._config ) operator.execute(None) mock_instance.load_file.assert_called_once_with('file', 'container', 'blob', timeout=2)
40.171875
105
0.710618
[ "Apache-2.0" ]
0411tony/airflow
tests/providers/microsoft/azure/transfers/test_local_to_wasb.py
2,571
Python
import sys sys.path.append("./stqft") sys.path.append("./qcnn") import os #Activate the cuda env os.environ["LD_LIBRARY_PATH"] = "$LD_LIBRARY_PATH:/usr/local/cuda/lib64/:/usr/lib64:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda-11.2/lib64:/usr/local/cuda/targets/x86_64-linux/lib/" import time import multiprocessing import glob import numpy as np datasetPath = "/storage/mstrobl/dataset" featurePath = "/storage/mstrobl/features" checkpointsPath = "/storage/mstrobl/checkpoints" modelsPath = "/storage/mstrobl/models" quantumPath = "/storage/mstrobl/dataQuantum" waveformPath = "/storage/mstrobl/waveforms" checkpointsPath = "/storage/mstrobl/checkpoints" exportPath = "/storage/mstrobl/versioning" TOPIC = "PrepGenTrain" batchSize = 28 kernelSize = 2 epochs = 40 portion = 1 PoolSize = int(multiprocessing.cpu_count()*0.6) #be gentle.. # PoolSize = 1 #be gentle.. if __name__ == '__main__': import argparse parser = argparse.ArgumentParser() parser.add_argument("--waveform", default = 1, help = "Generate Waveforms") parser.add_argument("--quantum", default= 1, help = "Generate Quantum Data") parser.add_argument("--train", default = 1, action='store_true', help = "Fit the model") parser.add_argument("--checkTree", default = 1, help = "Checks if the working tree is dirty") args = parser.parse_args() from stqft.frontend import export if int(args.checkTree) == 1: export.checkWorkingTree(exportPath) print(f"\n\n\n-----------------------\n\n\n") print(f"Train Time @{time.time()}") print(f"\n\n\n-----------------------\n\n\n") multiprocessing.set_start_method('spawn') print(f"Running {PoolSize} processes") datasetFiles = glob.glob(datasetPath + "/**/*.wav", recursive=True) print(f"Found {len(datasetFiles)} files in the dataset") exp = export(topic=TOPIC, identifier="dataset", dataDir=exportPath) exp.setData(export.DESCRIPTION, f"Dataset {len(datasetFiles)} in {datasetPath}") exp.setData(export.GENERICDATA, datasetFiles) exp.doExport() print(f"\n\n\n-----------------------\n\n\n") print(f"Generating Waveforms @{time.time()}") print(f"\n\n\n-----------------------\n\n\n") from generateFeatures import gen_features, gen_quantum, reportSettings, samplingRate from qcnn.small_qsr import labels if int(args.waveform)==1: x_train, x_valid, y_train, y_valid = gen_features(labels, datasetPath, featurePath, PoolSize, waveformPath=waveformPath, portion=portion) else: print("Loading from disk...") x_train = np.load(f"{featurePath}/x_train_speech.npy") x_valid = np.load(f"{featurePath}/x_valid_speech.npy") y_train = np.load(f"{featurePath}/y_train_speech.npy") y_valid = np.load(f"{featurePath}/y_valid_speech.npy") exp = export(topic=TOPIC, identifier="waveformData", dataDir=exportPath) exp.setData(export.DESCRIPTION, f"Waveforms generated (T)/ loaded (F): {args.waveform}; Labels used: {labels}; FeaturePath: {featurePath}; PoolSize: {PoolSize}; WaveformPath: {waveformPath}; Portioning: {portion}, SamplingRate: {samplingRate}, {reportSettings()}") exp.setData(export.GENERICDATA, {"x_train":x_train, "x_valid":x_valid, "y_train":y_train, "y_valid":y_valid}) exp.doExport() print(f"\n\n\n-----------------------\n\n\n") print(f"Generating Quantum Data @{time.time()}") print(f"\n\n\n-----------------------\n\n\n") # disable quanv and pix chan mal if int(args.quantum)==-2: q_train = x_train q_valid = x_valid # enable quanv elif int(args.quantum)==1: q_train, q_valid = gen_quantum(x_train, x_valid, kernelSize, output=quantumPath, poolSize=PoolSize) # pix chan map elif int(args.quantum)==-1: q_train, q_valid = gen_quantum(x_train, x_valid, kernelSize, output=quantumPath, poolSize=PoolSize, quanv=False) # load from disk else: print("Loading from disk...") q_train = np.load(f"{quantumPath}/quanv_train.npy") q_valid = np.load(f"{quantumPath}/quanv_valid.npy") exp = export(topic=TOPIC, identifier="quantumData", dataDir=exportPath) exp.setData(export.DESCRIPTION, f"Quantum data generated (T)/ loaded (F): {args.quantum}; FeaturePath: {quantumPath}; PoolSize: {PoolSize};") exp.setData(export.GENERICDATA, {"q_train":q_train, "q_valid":q_valid}) exp.doExport() print(f"\n\n\n-----------------------\n\n\n") print(f"Starting Training @{time.time()}") print(f"\n\n\n-----------------------\n\n\n") from fitModel import fit_model if args.train: #if quanv completely disabled and no pix channel map if int(args.quantum)==-2 or q_train.shape[3]==1: print("using ablation") # pass quanv data for training and validation model, history = fit_model(q_train, y_train, q_valid, y_valid, checkpointsPath, epochs=epochs, batchSize=batchSize, ablation=True) else: # pass quanv data for training and validation model, history = fit_model(q_train, y_train, q_valid, y_valid, checkpointsPath, epochs=epochs, batchSize=batchSize, ablation=False) data_ix = time.strftime("%Y%m%d_%H%M") model.save(f"{modelsPath}/model_{time.time()}") else: print("Training disabled") exp = export(topic=TOPIC, identifier="model", dataDir=exportPath) exp.setData(export.DESCRIPTION, f"Model trained (T)/ loaded (F): {args.train}; CheckpointsPath: {checkpointsPath}; ModelsPath: {modelsPath}") exp.setData(export.GENERICDATA, {"history_acc":history.history['accuracy'], "history_val_acc":history.history['val_accuracy'], "history_loss":history.history['loss'], "history_val_loss":history.history['val_loss']}) exp.doExport()
42.595588
268
0.669256
[ "MIT" ]
stroblme/hqsp-main
train.py
5,793
Python
# coding: utf-8 """ ThingsBoard REST API ThingsBoard Professional Edition IoT platform REST API documentation. # noqa: E501 OpenAPI spec version: 3.3.3PAAS-RC1 Contact: [email protected] Generated by: https://github.com/swagger-api/swagger-codegen.git """ from __future__ import absolute_import import re # noqa: F401 # python 2 and python 3 compatibility library import six from tb_rest_client.api_client import ApiClient class EntityGroupControllerApi(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. Ref: https://github.com/swagger-api/swagger-codegen """ def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def add_entities_to_entity_group_using_post(self, entity_group_id, **kwargs): # noqa: E501 """Add entities to the group (addEntitiesToEntityGroup) # noqa: E501 Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.add_entities_to_entity_group_using_post(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param list[str] body: :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 else: (data) = self.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 return data def add_entities_to_entity_group_using_post_with_http_info(self, entity_group_id, **kwargs): # noqa: E501 """Add entities to the group (addEntitiesToEntityGroup) # noqa: E501 Add entities to the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'ADD_TO_GROUP' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.add_entities_to_entity_group_using_post_with_http_info(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param list[str] body: :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id', 'body'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method add_entities_to_entity_group_using_post" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `add_entities_to_entity_group_using_post`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'body' in params: body_params = params['body'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/addEntities', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def assign_entity_group_to_edge_using_post(self, edge_id, group_type, entity_group_id, **kwargs): # noqa: E501 """Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501 Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.assign_entity_group_to_edge_using_post(edge_id, group_type, entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: EntityGroup If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, **kwargs) # noqa: E501 else: (data) = self.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, **kwargs) # noqa: E501 return data def assign_entity_group_to_edge_using_post_with_http_info(self, edge_id, group_type, entity_group_id, **kwargs): # noqa: E501 """Assign entity group to edge (assignEntityGroupToEdge) # noqa: E501 Creates assignment of an existing entity group to an instance of The Edge. Assignment works in async way - first, notification event pushed to edge service queue on platform. Second, remote edge service will receive a copy of assignment entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once entity group will be delivered to edge service, edge will request entities of this group to be send to edge. Once entities will be delivered to edge service, they are going to be available for usage on remote edge instance. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.assign_entity_group_to_edge_using_post_with_http_info(edge_id, group_type, entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: EntityGroup If the method is called asynchronously, returns the request thread. """ all_params = ['edge_id', 'group_type', 'entity_group_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method assign_entity_group_to_edge_using_post" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'edge_id' is set if ('edge_id' not in params or params['edge_id'] is None): raise ValueError("Missing the required parameter `edge_id` when calling `assign_entity_group_to_edge_using_post`") # noqa: E501 # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `assign_entity_group_to_edge_using_post`") # noqa: E501 # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `assign_entity_group_to_edge_using_post`") # noqa: E501 collection_formats = {} path_params = {} if 'edge_id' in params: path_params['edgeId'] = params['edge_id'] # noqa: E501 if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/edge/{edgeId}/entityGroup/{entityGroupId}/{groupType}', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroup', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def delete_entity_group_using_delete(self, entity_group_id, **kwargs): # noqa: E501 """Delete Entity Group (deleteEntityGroup) # noqa: E501 Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_entity_group_using_delete(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.delete_entity_group_using_delete_with_http_info(entity_group_id, **kwargs) # noqa: E501 else: (data) = self.delete_entity_group_using_delete_with_http_info(entity_group_id, **kwargs) # noqa: E501 return data def delete_entity_group_using_delete_with_http_info(self, entity_group_id, **kwargs): # noqa: E501 """Delete Entity Group (deleteEntityGroup) # noqa: E501 Deletes the entity group but does not delete the entities in the group, since they are also present in reserved group 'All'. Referencing non-existing Entity Group Id will cause an error. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'DELETE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_entity_group_using_delete_with_http_info(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method delete_entity_group_using_delete" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `delete_entity_group_using_delete`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}', 'DELETE', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_all_edge_entity_groups_using_get(self, edge_id, group_type, **kwargs): # noqa: E501 """Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501 Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_all_edge_entity_groups_using_get(edge_id, group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :return: list[EntityGroupInfo] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, **kwargs) # noqa: E501 else: (data) = self.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, **kwargs) # noqa: E501 return data def get_all_edge_entity_groups_using_get_with_http_info(self, edge_id, group_type, **kwargs): # noqa: E501 """Get All Edge Entity Groups by entity type (getAllEdgeEntityGroups) # noqa: E501 Fetch the list of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_all_edge_entity_groups_using_get_with_http_info(edge_id, group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :return: list[EntityGroupInfo] If the method is called asynchronously, returns the request thread. """ all_params = ['edge_id', 'group_type'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_all_edge_entity_groups_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'edge_id' is set if ('edge_id' not in params or params['edge_id'] is None): raise ValueError("Missing the required parameter `edge_id` when calling `get_all_edge_entity_groups_using_get`") # noqa: E501 # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `get_all_edge_entity_groups_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'edge_id' in params: path_params['edgeId'] = params['edge_id'] # noqa: E501 if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/allEntityGroups/edge/{edgeId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_edge_entity_groups_using_get(self, edge_id, group_type, page_size, page, **kwargs): # noqa: E501 """Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501 Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_edge_entity_groups_using_get(edge_id, group_type, page_size, page, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :param int page_size: Maximum amount of entities in a one page (required) :param int page: Sequence number of page starting from 0 (required) :param str sort_property: Property of entity to sort by :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING) :return: PageDataEntityGroupInfo If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, **kwargs) # noqa: E501 else: (data) = self.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, **kwargs) # noqa: E501 return data def get_edge_entity_groups_using_get_with_http_info(self, edge_id, group_type, page_size, page, **kwargs): # noqa: E501 """Get Edge Entity Groups by entity type (getEdgeEntityGroups) # noqa: E501 Returns a page of Entity Group Info objects based on the provided Entity Type and assigned to the provided Edge entity. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_edge_entity_groups_using_get_with_http_info(edge_id, group_type, page_size, page, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :param int page_size: Maximum amount of entities in a one page (required) :param int page: Sequence number of page starting from 0 (required) :param str sort_property: Property of entity to sort by :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING) :return: PageDataEntityGroupInfo If the method is called asynchronously, returns the request thread. """ all_params = ['edge_id', 'group_type', 'page_size', 'page', 'sort_property', 'sort_order'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_edge_entity_groups_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'edge_id' is set if ('edge_id' not in params or params['edge_id'] is None): raise ValueError("Missing the required parameter `edge_id` when calling `get_edge_entity_groups_using_get`") # noqa: E501 # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `get_edge_entity_groups_using_get`") # noqa: E501 # verify the required parameter 'page_size' is set if ('page_size' not in params or params['page_size'] is None): raise ValueError("Missing the required parameter `page_size` when calling `get_edge_entity_groups_using_get`") # noqa: E501 # verify the required parameter 'page' is set if ('page' not in params or params['page'] is None): raise ValueError("Missing the required parameter `page` when calling `get_edge_entity_groups_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'edge_id' in params: path_params['edgeId'] = params['edge_id'] # noqa: E501 if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 query_params = [] if 'page_size' in params: query_params.append(('pageSize', params['page_size'])) # noqa: E501 if 'page' in params: query_params.append(('page', params['page'])) # noqa: E501 if 'sort_property' in params: query_params.append(('sortProperty', params['sort_property'])) # noqa: E501 if 'sort_order' in params: query_params.append(('sortOrder', params['sort_order'])) # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroups/edge/{edgeId}/{groupType}{?page,pageSize,sortOrder,sortProperty}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataEntityGroupInfo', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entities_using_get(self, entity_group_id, page_size, page, **kwargs): # noqa: E501 """Get Group Entities (getEntities) # noqa: E501 Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entities_using_get(entity_group_id, page_size, page, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param int page_size: Maximum amount of entities in a one page (required) :param int page: Sequence number of page starting from 0 (required) :param str text_search: The case insensitive 'startsWith' filter based on the entity group name. :param str sort_property: Property of entity to sort by :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING) :return: PageDataShortEntityView If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entities_using_get_with_http_info(entity_group_id, page_size, page, **kwargs) # noqa: E501 else: (data) = self.get_entities_using_get_with_http_info(entity_group_id, page_size, page, **kwargs) # noqa: E501 return data def get_entities_using_get_with_http_info(self, entity_group_id, page_size, page, **kwargs): # noqa: E501 """Get Group Entities (getEntities) # noqa: E501 Returns a page of Short Entity View objects that belongs to specified Entity Group Id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entities_using_get_with_http_info(entity_group_id, page_size, page, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param int page_size: Maximum amount of entities in a one page (required) :param int page: Sequence number of page starting from 0 (required) :param str text_search: The case insensitive 'startsWith' filter based on the entity group name. :param str sort_property: Property of entity to sort by :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING) :return: PageDataShortEntityView If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id', 'page_size', 'page', 'text_search', 'sort_property', 'sort_order'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entities_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `get_entities_using_get`") # noqa: E501 # verify the required parameter 'page_size' is set if ('page_size' not in params or params['page_size'] is None): raise ValueError("Missing the required parameter `page_size` when calling `get_entities_using_get`") # noqa: E501 # verify the required parameter 'page' is set if ('page' not in params or params['page'] is None): raise ValueError("Missing the required parameter `page` when calling `get_entities_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] if 'page_size' in params: query_params.append(('pageSize', params['page_size'])) # noqa: E501 if 'page' in params: query_params.append(('page', params['page'])) # noqa: E501 if 'text_search' in params: query_params.append(('textSearch', params['text_search'])) # noqa: E501 if 'sort_property' in params: query_params.append(('sortProperty', params['sort_property'])) # noqa: E501 if 'sort_order' in params: query_params.append(('sortOrder', params['sort_order'])) # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/entities{?page,pageSize,sortOrder,sortProperty,textSearch}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataShortEntityView', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entity_group_all_by_owner_and_type_using_get(self, owner_type, owner_id, group_type, **kwargs): # noqa: E501 """Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501 Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_group_all_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str owner_type: Tenant or Customer (required) :param str owner_id: A string value representing the Tenant or Customer id (required) :param str group_type: Entity Group type (required) :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs) # noqa: E501 else: (data) = self.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs) # noqa: E501 return data def get_entity_group_all_by_owner_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, **kwargs): # noqa: E501 """Get special group All by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501 Fetch reserved group 'All' based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_group_all_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str owner_type: Tenant or Customer (required) :param str owner_id: A string value representing the Tenant or Customer id (required) :param str group_type: Entity Group type (required) :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ all_params = ['owner_type', 'owner_id', 'group_type'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entity_group_all_by_owner_and_type_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'owner_type' is set if ('owner_type' not in params or params['owner_type'] is None): raise ValueError("Missing the required parameter `owner_type` when calling `get_entity_group_all_by_owner_and_type_using_get`") # noqa: E501 # verify the required parameter 'owner_id' is set if ('owner_id' not in params or params['owner_id'] is None): raise ValueError("Missing the required parameter `owner_id` when calling `get_entity_group_all_by_owner_and_type_using_get`") # noqa: E501 # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `get_entity_group_all_by_owner_and_type_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'owner_type' in params: path_params['ownerType'] = params['owner_type'] # noqa: E501 if 'owner_id' in params: path_params['ownerId'] = params['owner_id'] # noqa: E501 if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/all/{ownerType}/{ownerId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entity_group_by_id_using_get(self, entity_group_id, **kwargs): # noqa: E501 """Get Entity Group Info (getEntityGroupById) # noqa: E501 Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_group_by_id_using_get(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entity_group_by_id_using_get_with_http_info(entity_group_id, **kwargs) # noqa: E501 else: (data) = self.get_entity_group_by_id_using_get_with_http_info(entity_group_id, **kwargs) # noqa: E501 return data def get_entity_group_by_id_using_get_with_http_info(self, entity_group_id, **kwargs): # noqa: E501 """Get Entity Group Info (getEntityGroupById) # noqa: E501 Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_group_by_id_using_get_with_http_info(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entity_group_by_id_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `get_entity_group_by_id_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entity_group_by_owner_and_name_and_type_using_get(self, owner_type, owner_id, group_type, group_name, **kwargs): # noqa: E501 """Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501 Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get(owner_type, owner_id, group_type, group_name, async_req=True) >>> result = thread.get() :param async_req bool :param str owner_type: Tenant or Customer (required) :param str owner_id: A string value representing the Tenant or Customer id (required) :param str group_type: Entity Group type (required) :param str group_name: Entity Group name (required) :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, **kwargs) # noqa: E501 else: (data) = self.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, **kwargs) # noqa: E501 return data def get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, group_name, **kwargs): # noqa: E501 """Get Entity Group by owner, type and name (getEntityGroupByOwnerAndNameAndType) # noqa: E501 Fetch the Entity Group object based on the provided Entity Group Id. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_group_by_owner_and_name_and_type_using_get_with_http_info(owner_type, owner_id, group_type, group_name, async_req=True) >>> result = thread.get() :param async_req bool :param str owner_type: Tenant or Customer (required) :param str owner_id: A string value representing the Tenant or Customer id (required) :param str group_type: Entity Group type (required) :param str group_name: Entity Group name (required) :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ all_params = ['owner_type', 'owner_id', 'group_type', 'group_name'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entity_group_by_owner_and_name_and_type_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'owner_type' is set if ('owner_type' not in params or params['owner_type'] is None): raise ValueError("Missing the required parameter `owner_type` when calling `get_entity_group_by_owner_and_name_and_type_using_get`") # noqa: E501 # verify the required parameter 'owner_id' is set if ('owner_id' not in params or params['owner_id'] is None): raise ValueError("Missing the required parameter `owner_id` when calling `get_entity_group_by_owner_and_name_and_type_using_get`") # noqa: E501 # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `get_entity_group_by_owner_and_name_and_type_using_get`") # noqa: E501 # verify the required parameter 'group_name' is set if ('group_name' not in params or params['group_name'] is None): raise ValueError("Missing the required parameter `group_name` when calling `get_entity_group_by_owner_and_name_and_type_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'owner_type' in params: path_params['ownerType'] = params['owner_type'] # noqa: E501 if 'owner_id' in params: path_params['ownerId'] = params['owner_id'] # noqa: E501 if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 if 'group_name' in params: path_params['groupName'] = params['group_name'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{ownerType}/{ownerId}/{groupType}/{groupName}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entity_groups_by_ids_using_get(self, entity_group_ids, **kwargs): # noqa: E501 """Get Entity Groups by Ids (getDevicesByIds) # noqa: E501 Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_by_ids_using_get(entity_group_ids, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_ids: A list of group ids, separated by comma ',' (required) :return: list[EntityGroup] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, **kwargs) # noqa: E501 else: (data) = self.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, **kwargs) # noqa: E501 return data def get_entity_groups_by_ids_using_get_with_http_info(self, entity_group_ids, **kwargs): # noqa: E501 """Get Entity Groups by Ids (getDevicesByIds) # noqa: E501 Requested devices must be owned by tenant or assigned to customer which user is performing the request. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_by_ids_using_get_with_http_info(entity_group_ids, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_ids: A list of group ids, separated by comma ',' (required) :return: list[EntityGroup] If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_ids'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entity_groups_by_ids_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_ids' is set if ('entity_group_ids' not in params or params['entity_group_ids'] is None): raise ValueError("Missing the required parameter `entity_group_ids` when calling `get_entity_groups_by_ids_using_get`") # noqa: E501 collection_formats = {} path_params = {} query_params = [] if 'entity_group_ids' in params: query_params.append(('entityGroupIds', params['entity_group_ids'])) # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroups{?entityGroupIds}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroup]', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entity_groups_by_owner_and_type_using_get(self, owner_type, owner_id, group_type, **kwargs): # noqa: E501 """Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501 Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_by_owner_and_type_using_get(owner_type, owner_id, group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str owner_type: Tenant or Customer (required) :param str owner_id: A string value representing the Tenant or Customer id (required) :param str group_type: Entity Group type (required) :return: list[EntityGroupInfo] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs) # noqa: E501 else: (data) = self.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, **kwargs) # noqa: E501 return data def get_entity_groups_by_owner_and_type_using_get_with_http_info(self, owner_type, owner_id, group_type, **kwargs): # noqa: E501 """Get Entity Groups by owner and entity type (getEntityGroupsByOwnerAndType) # noqa: E501 Fetch the list of Entity Group Info objects based on the provided Owner Id and Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_by_owner_and_type_using_get_with_http_info(owner_type, owner_id, group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str owner_type: Tenant or Customer (required) :param str owner_id: A string value representing the Tenant or Customer id (required) :param str group_type: Entity Group type (required) :return: list[EntityGroupInfo] If the method is called asynchronously, returns the request thread. """ all_params = ['owner_type', 'owner_id', 'group_type'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entity_groups_by_owner_and_type_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'owner_type' is set if ('owner_type' not in params or params['owner_type'] is None): raise ValueError("Missing the required parameter `owner_type` when calling `get_entity_groups_by_owner_and_type_using_get`") # noqa: E501 # verify the required parameter 'owner_id' is set if ('owner_id' not in params or params['owner_id'] is None): raise ValueError("Missing the required parameter `owner_id` when calling `get_entity_groups_by_owner_and_type_using_get`") # noqa: E501 # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `get_entity_groups_by_owner_and_type_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'owner_type' in params: path_params['ownerType'] = params['owner_type'] # noqa: E501 if 'owner_id' in params: path_params['ownerId'] = params['owner_id'] # noqa: E501 if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroups/{ownerType}/{ownerId}/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entity_groups_by_type_using_get(self, group_type, **kwargs): # noqa: E501 """Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501 Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_by_type_using_get(group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str group_type: Entity Group type (required) :return: list[EntityGroupInfo] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entity_groups_by_type_using_get_with_http_info(group_type, **kwargs) # noqa: E501 else: (data) = self.get_entity_groups_by_type_using_get_with_http_info(group_type, **kwargs) # noqa: E501 return data def get_entity_groups_by_type_using_get_with_http_info(self, group_type, **kwargs): # noqa: E501 """Get Entity Groups by entity type (getEntityGroupsByType) # noqa: E501 Fetch the list of Entity Group Info objects based on the provided Entity Type. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously.Entity Group Info extends Entity Group object and adds 'ownerIds' - a list of owner ids. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_by_type_using_get_with_http_info(group_type, async_req=True) >>> result = thread.get() :param async_req bool :param str group_type: Entity Group type (required) :return: list[EntityGroupInfo] If the method is called asynchronously, returns the request thread. """ all_params = ['group_type'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entity_groups_by_type_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `get_entity_groups_by_type_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroups/{groupType}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupInfo]', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_entity_groups_for_entity_using_get(self, entity_type, entity_id, **kwargs): # noqa: E501 """Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501 Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_for_entity_using_get(entity_type, entity_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_type: Entity Group type (required) :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: list[EntityGroupId] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, **kwargs) # noqa: E501 else: (data) = self.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, **kwargs) # noqa: E501 return data def get_entity_groups_for_entity_using_get_with_http_info(self, entity_type, entity_id, **kwargs): # noqa: E501 """Get Entity Groups by Entity Id (getEntityGroupsForEntity) # noqa: E501 Returns a list of groups that contain the specified Entity Id. For example, all device groups that contain specific device. The list always contain at least one element - special group 'All'.You can specify parameters to filter the results. The result is wrapped with PageData object that allows you to iterate over result set using pagination. See the 'Model' tab of the Response Class for more details. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_entity_groups_for_entity_using_get_with_http_info(entity_type, entity_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_type: Entity Group type (required) :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: list[EntityGroupId] If the method is called asynchronously, returns the request thread. """ all_params = ['entity_type', 'entity_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_entity_groups_for_entity_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_type' is set if ('entity_type' not in params or params['entity_type'] is None): raise ValueError("Missing the required parameter `entity_type` when calling `get_entity_groups_for_entity_using_get`") # noqa: E501 # verify the required parameter 'entity_id' is set if ('entity_id' not in params or params['entity_id'] is None): raise ValueError("Missing the required parameter `entity_id` when calling `get_entity_groups_for_entity_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_type' in params: path_params['entityType'] = params['entity_type'] # noqa: E501 if 'entity_id' in params: path_params['entityId'] = params['entity_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroups/{entityType}/{entityId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[EntityGroupId]', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_group_entity_using_get(self, entity_group_id, entity_id, **kwargs): # noqa: E501 """Get Group Entity (getGroupEntity) # noqa: E501 Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_entity_using_get(entity_group_id, entity_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: ShortEntityView If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, **kwargs) # noqa: E501 else: (data) = self.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, **kwargs) # noqa: E501 return data def get_group_entity_using_get_with_http_info(self, entity_group_id, entity_id, **kwargs): # noqa: E501 """Get Group Entity (getGroupEntity) # noqa: E501 Fetch the Short Entity View object based on the group and entity id. Short Entity View object contains the entity id and number of fields (attributes, telemetry, etc). List of those fields is configurable and defined in the group configuration. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_group_entity_using_get_with_http_info(entity_group_id, entity_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str entity_id: A string value representing the entity id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: ShortEntityView If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id', 'entity_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_group_entity_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `get_group_entity_using_get`") # noqa: E501 # verify the required parameter 'entity_id' is set if ('entity_id' not in params or params['entity_id'] is None): raise ValueError("Missing the required parameter `entity_id` when calling `get_group_entity_using_get`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 if 'entity_id' in params: path_params['entityId'] = params['entity_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/{entityId}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='ShortEntityView', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def get_owners_using_get(self, page_size, page, **kwargs): # noqa: E501 """Get Owners (getOwners) # noqa: E501 Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_owners_using_get(page_size, page, async_req=True) >>> result = thread.get() :param async_req bool :param int page_size: Maximum amount of entities in a one page (required) :param int page: Sequence number of page starting from 0 (required) :param str text_search: The case insensitive 'startsWith' filter based on the entity group name. :param str sort_property: Property of entity to sort by :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING) :return: PageDataContactBasedobject If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.get_owners_using_get_with_http_info(page_size, page, **kwargs) # noqa: E501 else: (data) = self.get_owners_using_get_with_http_info(page_size, page, **kwargs) # noqa: E501 return data def get_owners_using_get_with_http_info(self, page_size, page, **kwargs): # noqa: E501 """Get Owners (getOwners) # noqa: E501 Provides a rage view of Customers that the current user has READ access to. If the current user is Tenant administrator, the result set also contains the tenant. The call is designed for the UI auto-complete component to show tenant and all possible Customers that the user may select to change the owner of the particular entity or entity group. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'READ' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_owners_using_get_with_http_info(page_size, page, async_req=True) >>> result = thread.get() :param async_req bool :param int page_size: Maximum amount of entities in a one page (required) :param int page: Sequence number of page starting from 0 (required) :param str text_search: The case insensitive 'startsWith' filter based on the entity group name. :param str sort_property: Property of entity to sort by :param str sort_order: Sort order. ASC (ASCENDING) or DESC (DESCENDING) :return: PageDataContactBasedobject If the method is called asynchronously, returns the request thread. """ all_params = ['page_size', 'page', 'text_search', 'sort_property', 'sort_order'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method get_owners_using_get" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'page_size' is set if ('page_size' not in params or params['page_size'] is None): raise ValueError("Missing the required parameter `page_size` when calling `get_owners_using_get`") # noqa: E501 # verify the required parameter 'page' is set if ('page' not in params or params['page'] is None): raise ValueError("Missing the required parameter `page` when calling `get_owners_using_get`") # noqa: E501 collection_formats = {} path_params = {} query_params = [] if 'page_size' in params: query_params.append(('pageSize', params['page_size'])) # noqa: E501 if 'page' in params: query_params.append(('page', params['page'])) # noqa: E501 if 'text_search' in params: query_params.append(('textSearch', params['text_search'])) # noqa: E501 if 'sort_property' in params: query_params.append(('sortProperty', params['sort_property'])) # noqa: E501 if 'sort_order' in params: query_params.append(('sortOrder', params['sort_order'])) # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/owners{?page,pageSize,sortOrder,sortProperty,textSearch}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='PageDataContactBasedobject', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def make_entity_group_private_using_post(self, entity_group_id, **kwargs): # noqa: E501 """Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501 Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.make_entity_group_private_using_post(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.make_entity_group_private_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 else: (data) = self.make_entity_group_private_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 return data def make_entity_group_private_using_post_with_http_info(self, entity_group_id, **kwargs): # noqa: E501 """Make Entity Group Private (makeEntityGroupPrivate) # noqa: E501 Make the entity group not available for non authorized users. Every group is private by default. This call is useful to hide the group that was previously made public. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.make_entity_group_private_using_post_with_http_info(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method make_entity_group_private_using_post" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `make_entity_group_private_using_post`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/makePrivate', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def make_entity_group_public_using_post(self, entity_group_id, **kwargs): # noqa: E501 """Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501 Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.make_entity_group_public_using_post(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.make_entity_group_public_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 else: (data) = self.make_entity_group_public_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 return data def make_entity_group_public_using_post_with_http_info(self, entity_group_id, **kwargs): # noqa: E501 """Make Entity Group Publicly available (makeEntityGroupPublic) # noqa: E501 Make the entity group available for non authorized users. Useful for public dashboards that will be embedded into the public websites. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.make_entity_group_public_using_post_with_http_info(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method make_entity_group_public_using_post" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `make_entity_group_public_using_post`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/makePublic', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def remove_entities_from_entity_group_using_post(self, entity_group_id, **kwargs): # noqa: E501 """Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501 Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.remove_entities_from_entity_group_using_post(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param list[str] body: :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 else: (data) = self.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 return data def remove_entities_from_entity_group_using_post_with_http_info(self, entity_group_id, **kwargs): # noqa: E501 """Remove entities from the group (removeEntitiesFromEntityGroup) # noqa: E501 Removes entities from the specified entity group. Entity group allows you to group multiple entities of the same entity type (Device, Asset, Customer, User, Dashboard, etc). Entity Group always have an owner - particular Tenant or Customer. Each entity may belong to multiple groups simultaneously. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'REMOVE_FROM_GROUP' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.remove_entities_from_entity_group_using_post_with_http_info(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param list[str] body: :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id', 'body'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method remove_entities_from_entity_group_using_post" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `remove_entities_from_entity_group_using_post`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'body' in params: body_params = params['body'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/deleteEntities', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def save_entity_group_using_post(self, **kwargs): # noqa: E501 """Create Or Update Entity Group (saveEntityGroup) # noqa: E501 Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.save_entity_group_using_post(async_req=True) >>> result = thread.get() :param async_req bool :param EntityGroup body: :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.save_entity_group_using_post_with_http_info(**kwargs) # noqa: E501 else: (data) = self.save_entity_group_using_post_with_http_info(**kwargs) # noqa: E501 return data def save_entity_group_using_post_with_http_info(self, **kwargs): # noqa: E501 """Create Or Update Entity Group (saveEntityGroup) # noqa: E501 Create or update the Entity Group. When creating Entity Group, platform generates Entity Group Id as [time-based UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). The newly created Entity Group Id will be present in the response. Specify existing Entity Group Id to update the group. Referencing non-existing Entity Group Id will cause 'Not Found' error. Entity group name is unique in the scope of owner and entity type. For example, you can't create two tenant device groups called 'Water meters'. However, you may create device and asset group with the same name. And also you may create groups with the same name for two different customers of the same tenant. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.save_entity_group_using_post_with_http_info(async_req=True) >>> result = thread.get() :param async_req bool :param EntityGroup body: :return: EntityGroupInfo If the method is called asynchronously, returns the request thread. """ all_params = ['body'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method save_entity_group_using_post" % key ) params[key] = val del params['kwargs'] collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'body' in params: body_params = params['body'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroupInfo', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def share_entity_group_to_child_owner_user_group_using_post(self, entity_group_id, user_group_id, role_id, **kwargs): # noqa: E501 """Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501 Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.share_entity_group_to_child_owner_user_group_using_post(entity_group_id, user_group_id, role_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, **kwargs) # noqa: E501 else: (data) = self.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, **kwargs) # noqa: E501 return data def share_entity_group_to_child_owner_user_group_using_post_with_http_info(self, entity_group_id, user_group_id, role_id, **kwargs): # noqa: E501 """Share the Entity Group with User group (shareEntityGroupToChildOwnerUserGroup) # noqa: E501 Share the entity group with specified user group using specified role. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.share_entity_group_to_child_owner_user_group_using_post_with_http_info(entity_group_id, user_group_id, role_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id that you would like to share. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str user_group_id: A string value representing the Entity(User) Group Id that you would like to share with. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str role_id: A string value representing the Role Id that describes set of permissions you would like to share (read, write, etc). For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id', 'user_group_id', 'role_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method share_entity_group_to_child_owner_user_group_using_post" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `share_entity_group_to_child_owner_user_group_using_post`") # noqa: E501 # verify the required parameter 'user_group_id' is set if ('user_group_id' not in params or params['user_group_id'] is None): raise ValueError("Missing the required parameter `user_group_id` when calling `share_entity_group_to_child_owner_user_group_using_post`") # noqa: E501 # verify the required parameter 'role_id' is set if ('role_id' not in params or params['role_id'] is None): raise ValueError("Missing the required parameter `role_id` when calling `share_entity_group_to_child_owner_user_group_using_post`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 if 'user_group_id' in params: path_params['userGroupId'] = params['user_group_id'] # noqa: E501 if 'role_id' in params: path_params['roleId'] = params['role_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/{userGroupId}/{roleId}/share', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def share_entity_group_using_post(self, entity_group_id, **kwargs): # noqa: E501 """Share the Entity Group (shareEntityGroup) # noqa: E501 Share the entity group with certain user group based on the provided Share Group Request. The request is quite flexible and processing of the request involves multiple security checks using platform RBAC feature. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.share_entity_group_using_post(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param ShareGroupRequest body: :return: None If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.share_entity_group_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 else: (data) = self.share_entity_group_using_post_with_http_info(entity_group_id, **kwargs) # noqa: E501 return data def share_entity_group_using_post_with_http_info(self, entity_group_id, **kwargs): # noqa: E501 """Share the Entity Group (shareEntityGroup) # noqa: E501 Share the entity group with certain user group based on the provided Share Group Request. The request is quite flexible and processing of the request involves multiple security checks using platform RBAC feature. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for specified group. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.share_entity_group_using_post_with_http_info(entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param ShareGroupRequest body: :return: None If the method is called asynchronously, returns the request thread. """ all_params = ['entity_group_id', 'body'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method share_entity_group_using_post" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `share_entity_group_using_post`") # noqa: E501 collection_formats = {} path_params = {} if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'body' in params: body_params = params['body'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/entityGroup/{entityGroupId}/share', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type=None, # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def unassign_entity_group_from_edge_using_delete(self, edge_id, group_type, entity_group_id, **kwargs): # noqa: E501 """Unassign entity group from edge (unassignEntityGroupFromEdge) # noqa: E501 Clears assignment of the entity group to the edge. Unassignment works in async way - first, 'unassign' notification event pushed to edge queue on platform. Second, remote edge service will receive an 'unassign' command to remove entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once 'unassign' command will be delivered to edge service, it's going to remove entity group and entities inside this group locally. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unassign_entity_group_from_edge_using_delete(edge_id, group_type, entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: EntityGroup If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.unassign_entity_group_from_edge_using_delete_with_http_info(edge_id, group_type, entity_group_id, **kwargs) # noqa: E501 else: (data) = self.unassign_entity_group_from_edge_using_delete_with_http_info(edge_id, group_type, entity_group_id, **kwargs) # noqa: E501 return data def unassign_entity_group_from_edge_using_delete_with_http_info(self, edge_id, group_type, entity_group_id, **kwargs): # noqa: E501 """Unassign entity group from edge (unassignEntityGroupFromEdge) # noqa: E501 Clears assignment of the entity group to the edge. Unassignment works in async way - first, 'unassign' notification event pushed to edge queue on platform. Second, remote edge service will receive an 'unassign' command to remove entity group (Edge will receive this instantly, if it's currently connected, or once it's going to be connected to platform). Third, once 'unassign' command will be delivered to edge service, it's going to remove entity group and entities inside this group locally. Available for users with 'TENANT_ADMIN' or 'CUSTOMER_USER' authority. Security check is performed to verify that the user has 'WRITE' permission for the entity (entities). # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.unassign_entity_group_from_edge_using_delete_with_http_info(edge_id, group_type, entity_group_id, async_req=True) >>> result = thread.get() :param async_req bool :param str edge_id: A string value representing the edge id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :param str group_type: EntityGroup type (required) :param str entity_group_id: A string value representing the Entity Group Id. For example, '784f394c-42b6-435a-983c-b7beff2784f9' (required) :return: EntityGroup If the method is called asynchronously, returns the request thread. """ all_params = ['edge_id', 'group_type', 'entity_group_id'] # noqa: E501 all_params.append('async_req') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method unassign_entity_group_from_edge_using_delete" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'edge_id' is set if ('edge_id' not in params or params['edge_id'] is None): raise ValueError("Missing the required parameter `edge_id` when calling `unassign_entity_group_from_edge_using_delete`") # noqa: E501 # verify the required parameter 'group_type' is set if ('group_type' not in params or params['group_type'] is None): raise ValueError("Missing the required parameter `group_type` when calling `unassign_entity_group_from_edge_using_delete`") # noqa: E501 # verify the required parameter 'entity_group_id' is set if ('entity_group_id' not in params or params['entity_group_id'] is None): raise ValueError("Missing the required parameter `entity_group_id` when calling `unassign_entity_group_from_edge_using_delete`") # noqa: E501 collection_formats = {} path_params = {} if 'edge_id' in params: path_params['edgeId'] = params['edge_id'] # noqa: E501 if 'group_type' in params: path_params['groupType'] = params['group_type'] # noqa: E501 if 'entity_group_id' in params: path_params['entityGroupId'] = params['entity_group_id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['X-Authorization'] # noqa: E501 return self.api_client.call_api( '/api/edge/{edgeId}/entityGroup/{entityGroupId}/{groupType}', 'DELETE', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='EntityGroup', # noqa: E501 auth_settings=auth_settings, async_req=params.get('async_req'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats)
56.113752
911
0.670978
[ "Apache-2.0" ]
D34DPlayer/thingsboard-python-rest-client
tb_rest_client/api/api_pe/entity_group_controller_api.py
132,204
Python
from distutils.core import setup setup( name='filekit', version='0.1', packages=['filekit'], license='MIT', long_description=open('README.md').read(), long_description_content_type='md' )
19.363636
46
0.661972
[ "MIT" ]
foundling/filekit
setup.py
213
Python
#========================================================== # # This prepare the hdf5 datasets of the DRIVE database # #============================================================ import os import h5py import numpy as np from PIL import Image #content/add2/E2/DRIVE_datasets_training_testing def write_hdf5(arr,outfile): with h5py.File(outfile,"w") as f: f.create_dataset("image", data=arr, dtype=arr.dtype) #------------Path of the images -------------------------------------------------------------- #train original_imgs_train = "/content/add2/E2/training/images/" groundTruth_imgs_train = "/content/add2/E2/training/1st_manual/" borderMasks_imgs_train = "/content/add2/E2/training/mask/" #test original_imgs_test = "/content/add2/E2//test/images/" groundTruth_imgs_test = "/content/add2/E2/test/1st_manual/" borderMasks_imgs_test = "content/add2/E2/test/mask/" #--------------------------------------------------------------------------------------------- Nimgs = 20 channels = 3 height = 584 width = 565 dataset_path = "/content/add2/E2/DRIVE_datasets_training_testing/" def get_datasets(imgs_dir,groundTruth_dir,borderMasks_dir,train_test="null"): imgs = np.empty((Nimgs,height,width,channels)) groundTruth = np.empty((Nimgs,height,width)) border_masks = np.empty((Nimgs,height,width)) for path, subdirs, files in os.walk(imgs_dir): #list all files, directories in the path for i in range(len(files)): #original print ("original image: " +files[i]) img = Image.open(imgs_dir+files[i]) imgs[i] = np.asarray(img) #corresponding ground truth groundTruth_name = files[i][0:2] + "_manual1.gif" print ("ground truth name: " + groundTruth_name) g_truth = Image.open(groundTruth_dir + groundTruth_name) groundTruth[i] = np.asarray(g_truth) #corresponding border masks border_masks_name = "" if train_test=="train": border_masks_name = files[i][0:2] + "_training_mask.gif" elif train_test=="test": border_masks_name = files[i][0:2] + "_test_mask.gif" else: print ("specify if train or test!!") exit() print ("border masks name: " + border_masks_name) b_mask = Image.open(borderMasks_dir + border_masks_name) border_masks[i] = np.asarray(b_mask) print ("imgs max: " +str(np.max(imgs))) print ("imgs min: " +str(np.min(imgs))) assert(np.max(groundTruth)==255 and np.max(border_masks)==255) assert(np.min(groundTruth)==0 and np.min(border_masks)==0) print ("ground truth and border masks are correctly withih pixel value range 0-255 (black-white)") #reshaping for my standard tensors imgs = np.transpose(imgs,(0,3,1,2)) assert(imgs.shape == (Nimgs,channels,height,width)) groundTruth = np.reshape(groundTruth,(Nimgs,1,height,width)) border_masks = np.reshape(border_masks,(Nimgs,1,height,width)) assert(groundTruth.shape == (Nimgs,1,height,width)) assert(border_masks.shape == (Nimgs,1,height,width)) return imgs, groundTruth, border_masks if not os.path.exists(dataset_path): os.makedirs(dataset_path) #getting the training datasets imgs_train, groundTruth_train, border_masks_train = get_datasets(original_imgs_train,groundTruth_imgs_train,borderMasks_imgs_train,"train") print ("saving train datasets") write_hdf5(imgs_train, dataset_path + "DRIVE_dataset_imgs_train.hdf5") write_hdf5(groundTruth_train, dataset_path + "DRIVE_dataset_groundTruth_train.hdf5") write_hdf5(border_masks_train,dataset_path + "DRIVE_dataset_borderMasks_train.hdf5") #getting the testing datasets imgs_test, groundTruth_test, border_masks_test = get_datasets(original_imgs_test,groundTruth_imgs_test,borderMasks_imgs_test,"test") print ("saving test datasets") write_hdf5(imgs_test,dataset_path + "DRIVE_dataset_imgs_test.hdf5") write_hdf5(groundTruth_test, dataset_path + "DRIVE_dataset_groundTruth_test.hdf5") write_hdf5(border_masks_test,dataset_path + "DRIVE_dataset_borderMasks_test.hdf5")
44.462366
139
0.662636
[ "MIT" ]
Hacker-007/E2
prepare_datasets_DRIVE.py
4,135
Python
import unittest from niedoida_test_case import NiedoidaTestCase class NiedoidaSmokeCaseMethodsRhf(NiedoidaTestCase): @classmethod def setUpClass(cls): cls.data = cls.run_calculations("smoke-methods-rhf") def test_energy(self): self.assertAlmostEqual(self.data.scfenergies[0], -2056.7986203616, 3) if __name__ == '__main__': unittest.main()
25.066667
77
0.739362
[ "MPL-2.0" ]
grzegorzmazur/niedoida
tests/niedoida/smoke-methods-rhf.py
376
Python
import cv2 cap = cv2.VideoCapture(1) cap.set(3, 640) #WIDTH cap.set(4, 480) #HEIGHT face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') while True: # while True: # ret, frame = cap.read() # # # Our operations on the frame come here # gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # faces = face_cascade.detectMultiScale(gray, 1.3, 5) # try: # number = len(faces) # size = [faces[0][2], faces[0][3]] # position = [faces[0][0], faces[0][1]] # break # except: # a = 1 ret, frame = cap.read() # Our operations on the frame come here gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) # print(number) # print(size) # print(position) #print(len(faces)) # Display the resulting frame for (x,y,w,h) in faces: cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = gray[y:y+h, x:x+w] roi_color = frame[y:y+h, x:x+w] cv2.imshow('frame',frame) if cv2.waitKey(1) & 0xFF == ord('q'): break # When everything done, release the capture cap.release() cv2.destroyAllWindows()
26.468085
75
0.578778
[ "MIT" ]
clevtech/Zhuldyz-Upper-RPI
faces.py
1,244
Python
#!/usr/bin/env python # Copyright (c) 2015-present, Facebook, Inc. # All rights reserved. # # This source code is licensed under the license found in the LICENSE file in # the root directory of this source tree. from __future__ import print_function from clang.cindex import Cursor, CursorKind, TokenKind from utils import range_dict_relative import ctypes import itertools import re # Function/method cursor kinds. FUNCTION_KINDS = set([ 'FUNCTION_DECL', 'FUNCTION_TEMPLATE', 'CXX_METHOD', 'CONSTRUCTOR', 'DESTRUCTOR', 'OBJC_INSTANCE_METHOD_DECL', 'OBJC_CLASS_METHOD_DECL', ]) # Class-like cursors. CLASS_KINDS = set([ 'STRUCT_DECL', 'UNION_DECL', 'CLASS_DECL', 'ENUM_DECL', 'OBJC_INTERFACE_DECL', 'OBJC_CATEGORY_DECL', 'OBJC_PROTOCOL_DECL', 'OBJC_IMPLEMENTATION_DECL', 'OBJC_CATEGORY_IMPL_DECL', 'CLASS_TEMPLATE', 'CLASS_TEMPLATE_PARTIAL_SPECIALIZATION', 'NAMESPACE', ]) # (Possibly external) members of CLASS_KINDS. MEMBER_KINDS = set([ 'CXX_METHOD', 'CONSTRUCTOR', 'DESTRUCTOR', 'FIELD_DECL', 'VAR_DECL', 'ENUM_CONSTANT_DECL', ]) # Variables and fields. VAR_KINDS = set([ 'OBJC_IVAR_DECL', 'FIELD_DECL', 'VAR_DECL', ]) # Capture the ubiquitous GTest-style TEST/TEST_F macros. GTEST_MACROS = set(['TEST', 'TEST_F']) MACRO_INSTANTIATION = 'MACRO_INSTANTIATION' OTHER_KINDS = set([ MACRO_INSTANTIATION, ]) # Record any of the cursor types listed above. ALL_KINDS = FUNCTION_KINDS | CLASS_KINDS | MEMBER_KINDS | VAR_KINDS | OTHER_KINDS # People like adding a '-' by convention, but strip that out. PRAGMA_MARK_REGEX = re.compile( '^[ \t]*#[ \t]*pragma[ \t]+mark[ \t]+(?:-[ \t]*)?(.+)$', re.MULTILINE) def visit_cursor(libclang, cursor): try: kind = cursor.kind.name except: # Some cursor kinds aren't supported by the Python binding. return None if kind not in ALL_KINDS: return None # Skip symbols from other files. if not libclang.clang_Location_isFromMainFile(cursor.location): return None # Names of function parameters. params = None # Names of template parameters. tparams = None children = None name = cursor.spelling # Display types for variables and typedefs. cursor_type = cursor.type.spelling if kind in VAR_KINDS else None if kind in FUNCTION_KINDS: # We can't use displayname as it also includes the arguments. params = [] tparams = [] for child in cursor.get_children(): if child.kind == CursorKind.PARM_DECL: # Use the param name, but fall back to the raw type if unnamed. params.append(child.spelling or child.type.spelling) elif child.kind == CursorKind.TEMPLATE_TYPE_PARAMETER: tparams.append(child.spelling) # TODO(hansonw): non-type and "template template" params? if kind in MEMBER_KINDS: # Name should be fully qualified if outside the parent. if cursor.semantic_parent != cursor.lexical_parent: name = cursor.semantic_parent.spelling + '::' + name elif kind in CLASS_KINDS: # Include template information. name = cursor.displayname children = [] for child in cursor.get_children(): child_outline = visit_cursor(libclang, child) if child_outline is not None: children.append(child_outline) if kind == MACRO_INSTANTIATION: params = [] if name in GTEST_MACROS: # Should look like TEST(id, id). tokens = list(itertools.islice(cursor.get_tokens(), 1, 6)) if len(tokens) == 5 and ( tokens[0].kind == TokenKind.PUNCTUATION and tokens[1].kind == TokenKind.IDENTIFIER and tokens[2].kind == TokenKind.PUNCTUATION and tokens[3].kind == TokenKind.IDENTIFIER and tokens[4].kind == TokenKind.PUNCTUATION ): params = [tokens[1].spelling, tokens[3].spelling] else: return None else: # TODO(hansonw): Handle other special macros like DEFINE_ params. return None ret = { 'name': name, 'cursor_kind': kind, 'cursor_type': cursor_type, 'extent': range_dict_relative(cursor.extent), 'params': params, 'tparams': tparams, 'children': children, } return {k: v for k, v in ret.items() if v is not None} # Scan through the outline tree and insert pragma marks as we pass by them. def insert_pragma_marks(marks, outline_tree, tree_end=None): new_result = [] for node in outline_tree: while len(marks) > 0: if marks[-1]['extent']['start']['row'] > node['extent']['start']['row']: break new_result.append(marks.pop()) children = node.get('children') if children: children[:] = insert_pragma_marks(marks, children, node['extent']['end']['row']) new_result.append(node) # Consume all remaining marks included in this subtree. while len(marks) > 0: if tree_end is not None and marks[-1]['extent']['start']['row'] > tree_end: break new_result.append(marks.pop()) return new_result def get_outline(libclang, translation_unit, contents): root_cursor = translation_unit.cursor # This is the same as Cursor.get_children minus an assert in visitor(). # This results in a ~2x speedup! callback_type = ctypes.CFUNCTYPE(ctypes.c_int, Cursor, Cursor, ctypes.py_object) def visitor(child, parent, result): child._tu = translation_unit child_outline = visit_cursor(libclang, child) if child_outline is not None: result.append(child_outline) return 1 # continue result = [] libclang.clang_visitChildren(root_cursor, callback_type(visitor), result) # Look for pragma marks. These are not detectable in the AST. line = 0 lastpos = 0 pragma_marks = [] for mark in PRAGMA_MARK_REGEX.finditer(contents): while lastpos < mark.start(): if contents[lastpos] == '\n': line += 1 lastpos += 1 pragma_marks.append({ 'name': mark.group(1), 'cursor_kind': 'PRAGMA_MARK', 'extent': { 'start': {'row': line, 'column': 0}, 'end': {'row': line + 1, 'column': 0}, }, }) # Top-level macro instantiations appear out of order. result = sorted(result, key=lambda x: ( x['extent']['start']['row'], x['extent']['start']['column'], x['extent']['end']['row'], x['extent']['end']['column'], )) # Convert into a stack for efficient removal. pragma_marks.reverse() return insert_pragma_marks(pragma_marks, result)
31.035714
92
0.621116
[ "Unlicense" ]
kevingatera/kgatewebapp
node_modules/nuclide/pkg/nuclide-clang-rpc/python/outline.py
6,952
Python
# -*- coding: utf-8 -*- """ @date Created on Fri May 22 2020 @author martin_g for Eomys """ # Third party imports import numpy as np from scipy import signal # Local application imports from mosqito.sq_metrics.loudness.loudness_zwtv._square_and_smooth import ( _square_and_smooth, ) def _third_octave_levels(sig, fs): """3rd octave filtering, squaring, smoothing, level calculation and downsampling to temporal resolution: 0,5 ms, i.e. sampling rate: 2 kHz See ISO 532-1 section 6.3 Parameters ---------- sig : numpy.ndarray time signal sampled at 48 kHz[pa] fs : int time signal sampling frequency Outputs ------- third_octave_levels : numpy.ndarray Set of time signals filtered per third octave bands """ # Sampling frequency shall be equal to 48 kHz (as per ISO 532) if fs != 48000: raise ValueError("""ERROR: Sampling frequency shall be equal to 48 kHz""") # Constants n_level_band = 28 n_filter_coeff = 6 dec_factor = int(fs / 2000) # Initialisation coeff = np.zeros(n_filter_coeff) # Filter coefficients of one-third-octave-band filters (reference # table) # ISO 532-1 Table A.1 third_octave_filter_ref = np.array( [[1, 2, 1, 1, -2, 1], [1, 0, -1, 1, -2, 1], [1, -2, 1, 1, -2, 1]] ) # Filter coefficients of one-third-octave-band filters (difference to # reference table for 28 one-third-octave-band filters) # ISO 532-1 Table A.2 third_octave_filter = np.array( [ [ [0, 0, 0, 0, -6.70260e-004, 6.59453e-004], [0, 0, 0, 0, -3.75071e-004, 3.61926e-004], [0, 0, 0, 0, -3.06523e-004, 2.97634e-004], ], [ [0, 0, 0, 0, -8.47258e-004, 8.30131e-004], [0, 0, 0, 0, -4.76448e-004, 4.55616e-004], [0, 0, 0, 0, -3.88773e-004, 3.74685e-004], ], [ [0, 0, 0, 0, -1.07210e-003, 1.04496e-003], [0, 0, 0, 0, -6.06567e-004, 5.73553e-004], [0, 0, 0, 0, -4.94004e-004, 4.71677e-004], ], [ [0, 0, 0, 0, -1.35836e-003, 1.31535e-003], [0, 0, 0, 0, -7.74327e-004, 7.22007e-004], [0, 0, 0, 0, -6.29154e-004, 5.93771e-004], ], [ [0, 0, 0, 0, -1.72380e-003, 1.65564e-003], [0, 0, 0, 0, -9.91780e-004, 9.08866e-004], [0, 0, 0, 0, -8.03529e-004, 7.47455e-004], ], [ [0, 0, 0, 0, -2.19188e-003, 2.08388e-003], [0, 0, 0, 0, -1.27545e-003, 1.14406e-003], [0, 0, 0, 0, -1.02976e-003, 9.40900e-004], ], [ [0, 0, 0, 0, -2.79386e-003, 2.62274e-003], [0, 0, 0, 0, -1.64828e-003, 1.44006e-003], [0, 0, 0, 0, -1.32520e-003, 1.18438e-003], ], [ [0, 0, 0, 0, -3.57182e-003, 3.30071e-003], [0, 0, 0, 0, -2.14252e-003, 1.81258e-003], [0, 0, 0, 0, -1.71397e-003, 1.49082e-003], ], [ [0, 0, 0, 0, -4.58305e-003, 4.15355e-003], [0, 0, 0, 0, -2.80413e-003, 2.28135e-003], [0, 0, 0, 0, -2.23006e-003, 1.87646e-003], ], [ [0, 0, 0, 0, -5.90655e-003, 5.22622e-003], [0, 0, 0, 0, -3.69947e-003, 2.87118e-003], [0, 0, 0, 0, -2.92205e-003, 2.36178e-003], ], [ [0, 0, 0, 0, -7.65243e-003, 6.57493e-003], [0, 0, 0, 0, -4.92540e-003, 3.61318e-003], [0, 0, 0, 0, -3.86007e-003, 2.97240e-003], ], [ [0, 0, 0, 0, -1.00023e-002, 8.29610e-003], [0, 0, 0, 0, -6.63788e-003, 4.55999e-003], [0, 0, 0, 0, -5.15982e-003, 3.75306e-003], ], [ [0, 0, 0, 0, -1.31230e-002, 1.04220e-002], [0, 0, 0, 0, -9.02274e-003, 5.73132e-003], [0, 0, 0, 0, -6.94543e-003, 4.71734e-003], ], [ [0, 0, 0, 0, -1.73693e-002, 1.30947e-002], [0, 0, 0, 0, -1.24176e-002, 7.20526e-003], [0, 0, 0, 0, -9.46002e-003, 5.93145e-003], ], [ [0, 0, 0, 0, -2.31934e-002, 1.64308e-002], [0, 0, 0, 0, -1.73009e-002, 9.04761e-003], [0, 0, 0, 0, -1.30358e-002, 7.44926e-003], ], [ [0, 0, 0, 0, -3.13292e-002, 2.06370e-002], [0, 0, 0, 0, -2.44342e-002, 1.13731e-002], [0, 0, 0, 0, -1.82108e-002, 9.36778e-003], ], [ [0, 0, 0, 0, -4.28261e-002, 2.59325e-002], [0, 0, 0, 0, -3.49619e-002, 1.43046e-002], [0, 0, 0, 0, -2.57855e-002, 1.17912e-002], ], [ [0, 0, 0, 0, -5.91733e-002, 3.25054e-002], [0, 0, 0, 0, -5.06072e-002, 1.79513e-002], [0, 0, 0, 0, -3.69401e-002, 1.48094e-002], ], [ [0, 0, 0, 0, -8.26348e-002, 4.05894e-002], [0, 0, 0, 0, -7.40348e-002, 2.24476e-002], [0, 0, 0, 0, -5.34977e-002, 1.85371e-002], ], [ [0, 0, 0, 0, -1.17018e-001, 5.08116e-002], [0, 0, 0, 0, -1.09516e-001, 2.81387e-002], [0, 0, 0, 0, -7.85097e-002, 2.32872e-002], ], [ [0, 0, 0, 0, -1.67714e-001, 6.37872e-002], [0, 0, 0, 0, -1.63378e-001, 3.53729e-002], [0, 0, 0, 0, -1.16419e-001, 2.93723e-002], ], [ [0, 0, 0, 0, -2.42528e-001, 7.98576e-002], [0, 0, 0, 0, -2.45161e-001, 4.43370e-002], [0, 0, 0, 0, -1.73972e-001, 3.70015e-002], ], [ [0, 0, 0, 0, -3.53142e-001, 9.96330e-002], [0, 0, 0, 0, -3.69163e-001, 5.53535e-002], [0, 0, 0, 0, -2.61399e-001, 4.65428e-002], ], [ [0, 0, 0, 0, -5.16316e-001, 1.24177e-001], [0, 0, 0, 0, -5.55473e-001, 6.89403e-002], [0, 0, 0, 0, -3.93998e-001, 5.86715e-002], ], [ [0, 0, 0, 0, -7.56635e-001, 1.55023e-001], [0, 0, 0, 0, -8.34281e-001, 8.58123e-002], [0, 0, 0, 0, -5.94547e-001, 7.43960e-002], ], [ [0, 0, 0, 0, -1.10165e000, 1.91713e-001], [0, 0, 0, 0, -1.23939e000, 1.05243e-001], [0, 0, 0, 0, -8.91666e-001, 9.40354e-002], ], [ [0, 0, 0, 0, -1.58477e000, 2.39049e-001], [0, 0, 0, 0, -1.80505e000, 1.28794e-001], [0, 0, 0, 0, -1.32500e000, 1.21333e-001], ], [ [0, 0, 0, 0, -2.50630e000, 1.42308e-001], [0, 0, 0, 0, -2.19464e000, 2.76470e-001], [0, 0, 0, 0, -1.90231e000, 1.47304e-001], ], ] ) # Filter gain values # ISO 532-1 Table A.2 filter_gain = np.array( [ 4.30764e-011, 8.59340e-011, 1.71424e-010, 3.41944e-010, 6.82035e-010, 1.36026e-009, 2.71261e-009, 5.40870e-009, 1.07826e-008, 2.14910e-008, 4.28228e-008, 8.54316e-008, 1.70009e-007, 3.38215e-007, 6.71990e-007, 1.33531e-006, 2.65172e-006, 5.25477e-006, 1.03780e-005, 2.04870e-005, 4.05198e-005, 7.97914e-005, 1.56511e-004, 3.04954e-004, 5.99157e-004, 1.16544e-003, 2.27488e-003, 3.91006e-003, ] ) # Definition of the range of preferred filter center frequency freq = [ 25, 31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, ] n_time = len(sig[::dec_factor]) time_axis = np.linspace(0, len(sig) / fs, num=n_time) third_octave_level = np.zeros((n_level_band, n_time)) for i_bands in range(n_level_band): # Initialisation tiny_value = 10 ** -12 i_ref = 4 * 10 ** -10 # 2nd order fltering (See ISO 532-1 section 6.3 and A.2) coeff = third_octave_filter_ref - third_octave_filter[i_bands, :, :] sig_filt = filter_gain[i_bands] * signal.sosfilt(coeff, sig) # Calculate center frequency of filter center_freq = 10 ** ((i_bands - 16) / 10) * 1000 # Squaring and smoothing of filtered signal sig_filt = _square_and_smooth(sig_filt, center_freq, 48000) # SPL calculation and decimation third_octave_level[i_bands, :] = 10 * np.log10( (sig_filt[::dec_factor] + tiny_value) / i_ref ) return third_octave_level, time_axis, freq
33.388112
82
0.428003
[ "Apache-2.0" ]
Igarciac117/MoSQITo
mosqito/sq_metrics/loudness/loudness_zwtv/_third_octave_levels.py
9,549
Python
# -*- coding: utf-8 -*- import uuid import pytz from faker import Faker from django.conf import settings from django.contrib.auth import get_user_model from django.contrib.gis.db.models import PointField from django.contrib.postgres.indexes import BrinIndex from django.contrib.postgres.fields import JSONField from django.core.validators import MaxValueValidator, MinValueValidator from django.db import models from django.template.defaultfilters import slugify from django.urls import reverse from django.utils.crypto import get_random_string from django.utils.functional import cached_property from django.utils.translation import ugettext_lazy as _ from django.utils import timezone from oauthlib.common import generate_token from oauth2_provider.models import ( Application, AbstractApplication, AbstractAccessToken, AccessToken, RefreshToken ) from foundation.constants import * class ProblemDataSheetManager(models.Manager): def delete_all(self): items = ProblemDataSheet.objects.all() for item in items.all(): item.delete() # def seed(self, user, product, length=25): # results = [] # faker = Faker('en_CA') # for i in range(0,length): # farm = ProblemDataSheet.objects.create( # name = faker.domain_word(), # description = faker.sentence(nb_words=6, variable_nb_words=True, ext_word_list=None), # user = user, # product = product, # ) # results.append(farm) # return results class ProblemDataSheet(models.Model): """ Class model represents danger / destructive element to a production crop. Special thanks: (1) Preventing, Diagnosing, and Correcting Common Houseplant Problems via URL https://extension.psu.edu/preventing-diagnosing-and-correcting-common-houseplant-problems """ ''' Metadata ''' class Meta: app_label = 'foundation' db_table = 'mika_problem_data_sheet' verbose_name = _('Problem Data Sheet') verbose_name_plural = _('Problem Data Sheets') default_permissions = () permissions = ( # ("can_get_opening_hours_specifications", "Can get opening hours specifications"), # ("can_get_opening_hours_specification", "Can get opening hours specifications"), # ("can_post_opening_hours_specification", "Can create opening hours specifications"), # ("can_put_opening_hours_specification", "Can update opening hours specifications"), # ("can_delete_opening_hours_specification", "Can delete opening hours specifications"), ) ''' Constants & Choices ''' class TYPE_OF: PEST = 1 DISEASE = 2 ABIOTIC = 3 NONE = 4 TYPE_OF_CHOICES = ( (TYPE_OF.PEST, _('Pest')), (TYPE_OF.DISEASE, _('Disease')), (TYPE_OF.ABIOTIC, _('Abiotic')), (TYPE_OF.NONE, _('None')), ) ''' Object Managers ''' objects = ProblemDataSheetManager() ''' Fields ''' # # Internal Related Fields # slug = models.SlugField( _("Slug"), help_text=_('The unique slug used for this crop when accessing details page.'), max_length=127, blank=True, null=False, db_index=True, unique=True, editable=False, ) text = models.CharField( _("Text"), max_length=127, help_text=_('The variety name of the crop.'), blank=True, null=True, db_index=True, ) type_of = models.PositiveSmallIntegerField( _("Type of"), help_text=_('The type of production crop problem.'), blank=False, null=False, choices=TYPE_OF_CHOICES, ) ''' Methods ''' def __str__(self): return str(self.slug)
28.223022
103
0.638542
[ "BSD-3-Clause" ]
mikaponics/mikaponics-back
mikaponics/foundation/models/problem_data_sheet.py
3,923
Python
# Copyright (c) 2015 - present Facebook, Inc. # All rights reserved. # # This source code is licensed under the BSD style license found in the # LICENSE file in the root directory of this source tree. An additional grant # of patent rights can be found in the PATENTS file in the same directory. import logging from . import util from inferlib import jwlib MODULE_NAME = __name__ MODULE_DESCRIPTION = '''Run analysis of code built with a command like: ant [options] [target] Analysis examples: infer -- ant compile''' LANG = ['java'] def gen_instance(*args): return AntCapture(*args) # This creates an empty argparser for the module, which provides only # description/usage information and no arguments. create_argparser = util.base_argparser(MODULE_DESCRIPTION, MODULE_NAME) class AntCapture: def __init__(self, args, cmd): self.args = args util.log_java_version() logging.info(util.run_cmd_ignore_fail(['ant', '-version'])) # TODO: make the extraction of targets smarter self.build_cmd = ['ant', '-verbose'] + cmd[1:] def is_interesting(self, content): return self.is_quoted(content) or content.endswith('.java') def is_quoted(self, argument): quote = '\'' return len(argument) > 2 and argument[0] == quote\ and argument[-1] == quote def remove_quotes(self, argument): if self.is_quoted(argument): return argument[1:-1] else: return argument def get_infer_commands(self, verbose_output): javac_pattern = '[javac]' argument_start_pattern = 'Compilation arguments' calls = [] javac_arguments = [] collect = False for line in verbose_output: if javac_pattern in line: if argument_start_pattern in line: collect = True if javac_arguments != []: capture = jwlib.create_infer_command(self.args, javac_arguments) calls.append(capture) javac_arguments = [] if collect: pos = line.index(javac_pattern) + len(javac_pattern) content = line[pos:].strip() if self.is_interesting(content): arg = self.remove_quotes(content) javac_arguments.append(arg) if javac_arguments != []: capture = jwlib.create_infer_command(self.args, javac_arguments) calls.append(capture) javac_arguments = [] return calls def capture(self): cmds = self.get_infer_commands(util.get_build_output(self.build_cmd)) clean_cmd = '%s clean' % self.build_cmd[0] return util.run_compilation_commands(cmds, clean_cmd)
34.297619
77
0.609511
[ "BSD-3-Clause" ]
stefb965/infer
infer/lib/python/inferlib/capture/ant.py
2,881
Python
#!/usr/bin/env python # --coding:utf-8-- # Copyright (c) 2020 vesoft inc. All rights reserved. # # This source code is licensed under Apache 2.0 License, # attached with Common Clause Condition 1.0, found in the LICENSES directory. import logging from nebula2.common.ttypes import ErrorCode from nebula2.Exception import ( AuthFailedException, IOErrorException, NotValidConnectionException, InValidHostname, ) from nebula2.data.ResultSet import ResultSet from nebula2.gclient.net.AuthResult import AuthResult from nebula2.gclient.net.Session import Session from nebula2.gclient.net.Connection import Connection from nebula2.gclient.net.ConnectionPool import ConnectionPool logging.basicConfig(level=logging.INFO, format='[%(asctime)s] %(levelname)-8s [%(filename)s:%(lineno)d]:%(message)s')
29.071429
117
0.782555
[ "Apache-2.0" ]
knwng/nebula-python
nebula2/gclient/net/__init__.py
814
Python
# Copyright (c) Microsoft Corporation. # Licensed under the MIT license. """ A family of functions used by CurvefittingAssessor """ import numpy as np all_models = {} model_para = {} model_para_num = {} curve_combination_models = ['vap', 'pow3', 'linear', 'logx_linear', 'dr_hill_zero_background', 'log_power', 'pow4', 'mmf', 'exp4', 'ilog2', 'weibull', 'janoschek'] def vap(x, a, b, c): """Vapor pressure model Parameters ---------- x : int a : float b : float c : float Returns ------- float np.exp(a+b/x+c*np.log(x)) """ return np.exp(a+b/x+c*np.log(x)) all_models['vap'] = vap model_para['vap'] = [-0.622028, -0.470050, 0.042322] model_para_num['vap'] = 3 def pow3(x, c, a, alpha): """pow3 Parameters ---------- x : int c : float a : float alpha : float Returns ------- float c - a * x**(-alpha) """ return c - a * x**(-alpha) all_models['pow3'] = pow3 model_para['pow3'] = [0.84, 0.52, 0.01] model_para_num['pow3'] = 3 def linear(x, a, b): """linear Parameters ---------- x : int a : float b : float Returns ------- float a*x + b """ return a*x + b all_models['linear'] = linear model_para['linear'] = [1., 0] model_para_num['linear'] = 2 def logx_linear(x, a, b): """logx linear Parameters ---------- x : int a : float b : float Returns ------- float a * np.log(x) + b """ x = np.log(x) return a*x + b all_models['logx_linear'] = logx_linear model_para['logx_linear'] = [0.378106, 0.046506] model_para_num['logx_linear'] = 2 def dr_hill_zero_background(x, theta, eta, kappa): """dr hill zero background Parameters ---------- x : int theta : float eta : float kappa : float Returns ------- float (theta* x**eta) / (kappa**eta + x**eta) """ return (theta* x**eta) / (kappa**eta + x**eta) all_models['dr_hill_zero_background'] = dr_hill_zero_background model_para['dr_hill_zero_background'] = [0.772320, 0.586449, 2.460843] model_para_num['dr_hill_zero_background'] = 3 def log_power(x, a, b, c): """"logistic power Parameters ---------- x : int a : float b : float c : float Returns ------- float a/(1.+(x/np.exp(b))**c) """ return a/(1.+(x/np.exp(b))**c) all_models['log_power'] = log_power model_para['log_power'] = [0.77, 2.98, -0.51] model_para_num['log_power'] = 3 def pow4(x, alpha, a, b, c): """pow4 Parameters ---------- x : int alpha : float a : float b : float c : float Returns ------- float c - (a*x+b)**-alpha """ return c - (a*x+b)**-alpha all_models['pow4'] = pow4 model_para['pow4'] = [0.1, 200, 0., 0.8] model_para_num['pow4'] = 4 def mmf(x, alpha, beta, kappa, delta): """Morgan-Mercer-Flodin http://www.pisces-conservation.com/growthhelp/index.html?morgan_mercer_floden.htm Parameters ---------- x : int alpha : float beta : float kappa : float delta : float Returns ------- float alpha - (alpha - beta) / (1. + (kappa * x)**delta) """ return alpha - (alpha - beta) / (1. + (kappa * x)**delta) all_models['mmf'] = mmf model_para['mmf'] = [0.7, 0.1, 0.01, 5] model_para_num['mmf'] = 4 def exp4(x, c, a, b, alpha): """exp4 Parameters ---------- x : int c : float a : float b : float alpha : float Returns ------- float c - np.exp(-a*(x**alpha)+b) """ return c - np.exp(-a*(x**alpha)+b) all_models['exp4'] = exp4 model_para['exp4'] = [0.7, 0.8, -0.8, 0.3] model_para_num['exp4'] = 4 def ilog2(x, c, a): """ilog2 Parameters ---------- x : int c : float a : float Returns ------- float c - a / np.log(x) """ return c - a / np.log(x) all_models['ilog2'] = ilog2 model_para['ilog2'] = [0.78, 0.43] model_para_num['ilog2'] = 2 def weibull(x, alpha, beta, kappa, delta): """Weibull model http://www.pisces-conservation.com/growthhelp/index.html?morgan_mercer_floden.htm Parameters ---------- x : int alpha : float beta : float kappa : float delta : float Returns ------- float alpha - (alpha - beta) * np.exp(-(kappa * x)**delta) """ return alpha - (alpha - beta) * np.exp(-(kappa * x)**delta) all_models['weibull'] = weibull model_para['weibull'] = [0.7, 0.1, 0.01, 1] model_para_num['weibull'] = 4 def janoschek(x, a, beta, k, delta): """http://www.pisces-conservation.com/growthhelp/janoschek.htm Parameters ---------- x : int a : float beta : float k : float delta : float Returns ------- float a - (a - beta) * np.exp(-k*x**delta) """ return a - (a - beta) * np.exp(-k*x**delta) all_models['janoschek'] = janoschek model_para['janoschek'] = [0.73, 0.07, 0.355, 0.46] model_para_num['janoschek'] = 4
18.644689
122
0.532417
[ "MIT" ]
Ascarshen/nni
src/sdk/pynni/nni/curvefitting_assessor/curvefunctions.py
5,090
Python
from ourstylePy import data def our_colours(colours=[]): ''' Extract hexcodes for our colours If passed a sting, returns the matching hexcode. If passed a list, returns a list of hexcodes. Method from https://drsimonj.svbtle.com/creating-corporate-colour-palettes-for-ggplot2. - colours, list of strings Examples: data.our_colours_raw our_colours() our_colours('green', 'blue', 'green') our_colours('not a colour', 'also not a colour', 'green') our_colors('blue') ''' if len(colours) == 0: return data.our_colours_raw elif isinstance(colours, str): return data.our_colours_raw[colours] else: return [data.our_colours_raw[i] for i in colours] def our_colors(colours=[]): ''' Alias for our_colours() ''' return our_colours(colours)
27.9
91
0.665472
[ "MIT" ]
PeterGrahamJersey/ourstylePy
ourstylePy/our_colours.py
837
Python
from bayesianABTest import sampleSuccessRateForBinomial from numpy import mean def bestOfFive(A,B,C,D,E,F): return mean( (A > B) & (A > C) & (A > D) & (A > E) & (A > F)) ############# Example: Binomial Distribution ############# # Actual data for all cases installs = [986,1013,959,968,1029,1014] returns = [340,298,274,287,325,291] A = sampleSuccessRateForBinomial(installs[0],returns[0]) B = sampleSuccessRateForBinomial(installs[1],returns[1]) C = sampleSuccessRateForBinomial(installs[2],returns[2]) D = sampleSuccessRateForBinomial(installs[3],returns[3]) E = sampleSuccessRateForBinomial(installs[4],returns[4]) F = sampleSuccessRateForBinomial(installs[5],returns[5]) A_best = bestOfFive(A,B,C,D,E,F) B_best = bestOfFive(B,A,C,D,E,F) C_best = bestOfFive(C,B,A,D,E,F) D_best = bestOfFive(D,B,C,A,E,F) E_best = bestOfFive(E,B,C,D,A,F) F_best = bestOfFive(F,B,C,D,E,A) # Get samples from the posterior print "The probability of 20 being the best choice is {}".format(A_best) print "The probability of 21 being the best choice is {}".format(B_best) print "The probability of 22 being the best choice is {}".format(C_best) print "The probability of 23 being the best choice is {}".format(D_best) print "The probability of 24 being the best choice is {}".format(E_best) print "The probability of 25 being the best choice is {}".format(F_best)
38.714286
72
0.720295
[ "Apache-2.0" ]
hugopibernat/BayesianABTestAnalysis
code/examples/example_mikhail.py
1,355
Python
__version__ = "2.2.3" # Work around to update TensorFlow's absl.logging threshold which alters the # default Python logging output behavior when present. # see: https://github.com/abseil/abseil-py/issues/99 # and: https://github.com/tensorflow/tensorflow/issues/26691#issuecomment-500369493 try: import absl.logging absl.logging.set_verbosity('info') absl.logging.set_stderrthreshold('info') absl.logging._warn_preinit_stderr = False except: pass import logging logger = logging.getLogger(__name__) # pylint: disable=invalid-name # Files and general utilities from .file_utils import (TRANSFORMERS_CACHE, PYTORCH_TRANSFORMERS_CACHE, PYTORCH_PRETRAINED_BERT_CACHE, cached_path, add_start_docstrings, add_end_docstrings, WEIGHTS_NAME, TF2_WEIGHTS_NAME, TF_WEIGHTS_NAME, CONFIG_NAME, is_tf_available, is_torch_available) from .data import (is_sklearn_available, InputExample, InputFeatures, DataProcessor, glue_output_modes, glue_convert_examples_to_features, glue_processors, glue_tasks_num_labels, xnli_output_modes, xnli_processors, xnli_tasks_num_labels, squad_convert_examples_to_features, SquadFeatures, SquadExample, SquadV1Processor, SquadV2Processor) if is_sklearn_available(): from .data import glue_compute_metrics, xnli_compute_metrics # ETRI modified ver from .etri_tf_tokenization import FullTokenizer # Tokenizers from .tokenization_utils import (PreTrainedTokenizer) from .tokenization_auto import AutoTokenizer from .tokenization_bert import BertTokenizer, BasicTokenizer, WordpieceTokenizer from .tokenization_bert_japanese import BertJapaneseTokenizer, MecabTokenizer, CharacterTokenizer from .tokenization_openai import OpenAIGPTTokenizer from .tokenization_transfo_xl import (TransfoXLTokenizer, TransfoXLCorpus) from .tokenization_gpt2 import GPT2Tokenizer from .tokenization_ctrl import CTRLTokenizer from .tokenization_xlnet import XLNetTokenizer, SPIECE_UNDERLINE from .tokenization_xlm import XLMTokenizer from .tokenization_roberta import RobertaTokenizer from .tokenization_distilbert import DistilBertTokenizer from .tokenization_albert import AlbertTokenizer from .tokenization_camembert import CamembertTokenizer from .tokenization_t5 import T5Tokenizer # Configurations from .configuration_utils import PretrainedConfig from .configuration_auto import AutoConfig from .configuration_bert import BertConfig, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_openai import OpenAIGPTConfig, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_transfo_xl import TransfoXLConfig, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_gpt2 import GPT2Config, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_ctrl import CTRLConfig, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_xlnet import XLNetConfig, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_xlm import XLMConfig, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_roberta import RobertaConfig, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_distilbert import DistilBertConfig, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_albert import AlbertConfig, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_camembert import CamembertConfig, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP from .configuration_t5 import T5Config, T5_PRETRAINED_CONFIG_ARCHIVE_MAP # Modeling if is_torch_available(): from .modeling_utils import (PreTrainedModel, prune_layer, Conv1D) from .modeling_auto import (AutoModel, AutoModelForSequenceClassification, AutoModelForQuestionAnswering, AutoModelWithLMHead) from .modeling_bert import (BertPreTrainedModel, BertModel, BertForPreTraining, BertForMaskedLM, BertForNextSentencePrediction, BertForSequenceClassification, BertForMultipleChoice, BertForTokenClassification, BertForQuestionAnswering, load_tf_weights_in_bert, BERT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_openai import (OpenAIGPTPreTrainedModel, OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, load_tf_weights_in_openai_gpt, OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_transfo_xl import (TransfoXLPreTrainedModel, TransfoXLModel, TransfoXLLMHeadModel, AdaptiveEmbedding, load_tf_weights_in_transfo_xl, TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_gpt2 import (GPT2PreTrainedModel, GPT2Model, GPT2LMHeadModel, GPT2DoubleHeadsModel, load_tf_weights_in_gpt2, GPT2_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_ctrl import (CTRLPreTrainedModel, CTRLModel, CTRLLMHeadModel, CTRL_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_xlnet import (XLNetPreTrainedModel, XLNetModel, XLNetLMHeadModel, XLNetForSequenceClassification, XLNetForTokenClassification, XLNetForMultipleChoice, XLNetForQuestionAnsweringSimple, XLNetForQuestionAnswering, load_tf_weights_in_xlnet, XLNET_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_xlm import (XLMPreTrainedModel , XLMModel, XLMWithLMHeadModel, XLMForSequenceClassification, XLMForQuestionAnswering, XLMForQuestionAnsweringSimple, XLM_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_roberta import (RobertaForMaskedLM, RobertaModel, RobertaForSequenceClassification, RobertaForMultipleChoice, RobertaForTokenClassification, ROBERTA_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_distilbert import (DistilBertPreTrainedModel, DistilBertForMaskedLM, DistilBertModel, DistilBertForSequenceClassification, DistilBertForQuestionAnswering, DistilBertForTokenClassification, DISTILBERT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_camembert import (CamembertForMaskedLM, CamembertModel, CamembertForSequenceClassification, CamembertForMultipleChoice, CamembertForTokenClassification, CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_encoder_decoder import PreTrainedEncoderDecoder, Model2Model from .modeling_t5 import (T5PreTrainedModel, T5Model, T5WithLMHeadModel, load_tf_weights_in_t5, T5_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_albert import (AlbertPreTrainedModel, AlbertModel, AlbertForMaskedLM, AlbertForSequenceClassification, AlbertForQuestionAnswering, load_tf_weights_in_albert, ALBERT_PRETRAINED_MODEL_ARCHIVE_MAP) # Optimization from .optimization import (AdamW, get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup) # TensorFlow if is_tf_available(): from .modeling_tf_utils import TFPreTrainedModel, TFSharedEmbeddings, TFSequenceSummary, shape_list from .modeling_tf_auto import (TFAutoModel, TFAutoModelForSequenceClassification, TFAutoModelForQuestionAnswering, TFAutoModelWithLMHead) from .modeling_tf_bert import (TFBertPreTrainedModel, TFBertMainLayer, TFBertEmbeddings, TFBertModel, TFBertForPreTraining, TFBertForMaskedLM, TFBertForNextSentencePrediction, TFBertForSequenceClassification, TFBertForMultipleChoice, TFBertForTokenClassification, TFBertForQuestionAnswering, TF_BERT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_gpt2 import (TFGPT2PreTrainedModel, TFGPT2MainLayer, TFGPT2Model, TFGPT2LMHeadModel, TFGPT2DoubleHeadsModel, TF_GPT2_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_openai import (TFOpenAIGPTPreTrainedModel, TFOpenAIGPTMainLayer, TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_transfo_xl import (TFTransfoXLPreTrainedModel, TFTransfoXLMainLayer, TFTransfoXLModel, TFTransfoXLLMHeadModel, TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_xlnet import (TFXLNetPreTrainedModel, TFXLNetMainLayer, TFXLNetModel, TFXLNetLMHeadModel, TFXLNetForSequenceClassification, TFXLNetForTokenClassification, TFXLNetForQuestionAnsweringSimple, TF_XLNET_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_xlm import (TFXLMPreTrainedModel, TFXLMMainLayer, TFXLMModel, TFXLMWithLMHeadModel, TFXLMForSequenceClassification, TFXLMForQuestionAnsweringSimple, TF_XLM_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_roberta import (TFRobertaPreTrainedModel, TFRobertaMainLayer, TFRobertaModel, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFRobertaForTokenClassification, TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_distilbert import (TFDistilBertPreTrainedModel, TFDistilBertMainLayer, TFDistilBertModel, TFDistilBertForMaskedLM, TFDistilBertForSequenceClassification, TFDistilBertForTokenClassification, TFDistilBertForQuestionAnswering, TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_ctrl import (TFCTRLPreTrainedModel, TFCTRLModel, TFCTRLLMHeadModel, TF_CTRL_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_albert import (TFAlbertPreTrainedModel, TFAlbertModel, TFAlbertForMaskedLM, TFAlbertForSequenceClassification, TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_MAP) from .modeling_tf_t5 import (TFT5PreTrainedModel, TFT5Model, TFT5WithLMHeadModel, TF_T5_PRETRAINED_MODEL_ARCHIVE_MAP) # Optimization from .optimization_tf import (WarmUp, create_optimizer, AdamWeightDecay, GradientAccumulator) # TF 2.0 <=> PyTorch conversion utilities from .modeling_tf_pytorch_utils import (convert_tf_weight_name_to_pt_weight_name, load_pytorch_checkpoint_in_tf2_model, load_pytorch_weights_in_tf2_model, load_pytorch_model_in_tf2_model, load_tf2_checkpoint_in_pytorch_model, load_tf2_weights_in_pytorch_model, load_tf2_model_in_pytorch_model) if not is_tf_available() and not is_torch_available(): logger.warning("Neither PyTorch nor TensorFlow >= 2.0 have been found." "Models won't be available and only tokenizers, configuration" "and file/data utilities can be used.")
59.990385
128
0.677432
[ "Apache-2.0" ]
seongwookchun/transformers
transformers/__init__.py
12,478
Python
from ..http import dump_header from ..http import parse_set_header from ..utils import environ_property from ..utils import header_property class CORSRequestMixin(object): """A mixin for :class:`~werkzeug.wrappers.BaseRequest` subclasses that adds descriptors for Cross Origin Resource Sharing (CORS) headers. .. versionadded:: 1.0 """ origin = environ_property( "HTTP_ORIGIN", doc=( "The host that the request originated from. Set" " :attr:`~CORSResponseMixin.access_control_allow_origin` on" " the response to indicate which origins are allowed." ), ) access_control_request_headers = environ_property( "HTTP_ACCESS_CONTROL_REQUEST_HEADERS", load_func=parse_set_header, doc=( "Sent with a preflight request to indicate which headers" " will be sent with the cross origin request. Set" " :attr:`~CORSResponseMixin.access_control_allow_headers`" " on the response to indicate which headers are allowed." ), ) access_control_request_method = environ_property( "HTTP_ACCESS_CONTROL_REQUEST_METHOD", doc=( "Sent with a preflight request to indicate which method" " will be used for the cross origin request. Set" " :attr:`~CORSResponseMixin.access_control_allow_methods`" " on the response to indicate which methods are allowed." ), ) class CORSResponseMixin(object): """A mixin for :class:`~werkzeug.wrappers.BaseResponse` subclasses that adds descriptors for Cross Origin Resource Sharing (CORS) headers. .. versionadded:: 1.0 """ @property def access_control_allow_credentials(self): """Whether credentials can be shared by the browser to JavaScript code. As part of the preflight request it indicates whether credentials can be used on the cross origin request. """ return "Access-Control-Allow-Credentials" in self.headers @access_control_allow_credentials.setter def access_control_allow_credentials(self, value): if value is True: self.headers["Access-Control-Allow-Credentials"] = "true" else: self.headers.pop("Access-Control-Allow-Credentials", None) access_control_allow_headers = header_property( "Access-Control-Allow-Headers", load_func=parse_set_header, dump_func=dump_header, doc="Which headers can be sent with the cross origin request.", ) access_control_allow_methods = header_property( "Access-Control-Allow-Methods", load_func=parse_set_header, dump_func=dump_header, doc="Which methods can be used for the cross origin request.", ) access_control_allow_origin = header_property( "Access-Control-Allow-Origin", load_func=parse_set_header, dump_func=dump_header, doc="The origins that may make cross origin requests.", ) access_control_expose_headers = header_property( "Access-Control-Expose-Headers", load_func=parse_set_header, dump_func=dump_header, doc="Which headers can be shared by the browser to JavaScript code.", ) access_control_max_age = header_property( "Access-Control-Max-Age", load_func=int, dump_func=str, doc="The maximum age in seconds the access control settings can be cached for.", )
34.097087
88
0.669989
[ "MIT" ]
997Yi/Flask-web
venv/Lib/site-packages/werkzeug/wrappers/cors.py
3,512
Python
import os import RPi.GPIO as gpio import time import random from mesafe import distance motorhizi = 2.5 hiz = 100 aci2 = aci3 = aci4 = 6 aci = 5.5 in4 = 26 in3 = 4 in2 = 12 in1 = 8 solled = 9 sagled = 11 gpio.setwarnings(False) def init(): gpio.setwarnings(False) gpio.setmode(gpio.BCM) gpio.setup(22,gpio.OUT) gpio.setup(27,gpio.OUT) gpio.setup(17,gpio.OUT) gpio.setup(18,gpio.OUT) gpio.setup(in4,gpio.OUT) gpio.setup(in3,gpio.OUT) gpio.setup(in2,gpio.OUT) gpio.setup(in1,gpio.OUT) gpio.setup(21,gpio.OUT) gpio.setup(solled,gpio.OUT) gpio.setup(sagled,gpio.OUT) gpio.setup(23,gpio.IN) gpio.setup(24,gpio.IN) gpio.output(22,0) gpio.output(18,0) gpio.output(17,0) gpio.output(27,0) gpio.output(in4,0) gpio.output(in3,0) gpio.output(in2,0) gpio.output(in1,0) gpio.output(21,0) gpio.output(solled,0) gpio.output(sagled,0) def ileri(tf,ff): init() gpio.output(17,0) gpio.output(22,0) ip = gpio.PWM(27,50) ip2 = gpio.PWM(18,50) ip.start(ff) ip2.start(ff) tf = float(tf) tf = tf / motorhizi time.sleep(tf) gpio.cleanup() def geri(tf,ff): init() gpio.output(18,0) gpio.output(27,0) gp = gpio.PWM(22,50) gp2 = gpio.PWM(17,50) gp.start(ff) gp2.start(ff) tf = float(tf) tf = tf / motorhizi time.sleep(tf) gpio.cleanup() def sol(tf,ff): init() gpio.output(17,0) gpio.output(27,0) sp = gpio.PWM(22,50) sp2 = gpio.PWM(18,50) sp.start(ff) sp2.start(ff) tf = float(tf) tf = tf / motorhizi time.sleep(tf) gpio.cleanup() def sag(tf,ff): init() gpio.output(18,0) gpio.output(22,0) sap = gpio.PWM(27,50) sap2 = gpio.PWM(17,50) sap.start(ff) sap2.start(ff) tf = float(tf) tf = tf / motorhizi time.sleep(tf) gpio.cleanup() def dur(): init() gpio.output(22,0) gpio.output(17,0) gpio.output(18,0) gpio.output(27,0) gpio.cleanup() def adim1(tf,y): init() if (y == 1): # sol gpio.output(in1,1) gpio.output(in2,0) gpio.output(in3,0) gpio.output(in4,0) if (y == 0): # sag gpio.output(in1,0) gpio.output(in2,0) gpio.output(in3,0) gpio.output(in4,1) time.sleep(tf) gpio.cleanup() def adim2(tf,y): init() if (y == 1): # sol gpio.output(in1,0) gpio.output(in2,1) gpio.output(in3,0) gpio.output(in4,0) if (y == 0): # sag gpio.output(in1,0) gpio.output(in2,0) gpio.output(in3,1) gpio.output(in4,0) time.sleep(tf) gpio.cleanup() def adim3(tf,y): init() if (y == 1): # sol gpio.output(in1,0) gpio.output(in2,0) gpio.output(in3,1) gpio.output(in4,0) if (y == 0): # sag gpio.output(in1,0) gpio.output(in2,1) gpio.output(in3,0) gpio.output(in4,0) time.sleep(tf) gpio.cleanup() def adim4(tf,y): init() if (y == 1): # sol gpio.output(in1,0) gpio.output(in2,0) gpio.output(in3,0) gpio.output(in4,1) if (y == 0): # sag gpio.output(in1,1) gpio.output(in2,0) gpio.output(in3,0) gpio.output(in4,0) time.sleep(tf) gpio.cleanup() def stepper(tf,ff,yf): ff = float(ff) ff = ff / 1000 if (yf == 0): # sag for i in range(0,tf): adim1(ff,0) adim2(ff,0) adim3(ff,0) adim4(ff,0) if (yf == 1): # sol for i in range(0,tf): adim1(ff,1) adim2(ff,1) adim3(ff,1) adim4(ff,1) def servo(tf): gpio.setmode(gpio.BCM) gpio.setup(5,gpio.OUT) p = gpio.PWM(5,50) p.start(5.5) p.ChangeDutyCycle(tf) time.sleep(0.7) gpio.cleanup() def servo2(tf): gpio.setmode(gpio.BCM) gpio.setup(6,gpio.OUT) p2 = gpio.PWM(6,50) p2.start(6) p2.ChangeDutyCycle(tf) time.sleep(0.7) gpio.cleanup() def servo3(tf): gpio.setmode(gpio.BCM) gpio.setup(20,gpio.OUT) p3 = gpio.PWM(20,50) p3.start(6) p3.ChangeDutyCycle(tf) time.sleep(0.7) gpio.cleanup() def servo4(tf): gpio.setmode(gpio.BCM) gpio.setup(16,gpio.OUT) p3 = gpio.PWM(16,50) p3.start(6) p3.ChangeDutyCycle(tf) time.sleep(0.7) gpio.cleanup() def ses(tf,ff): init() sp = gpio.PWM(21,ff) sp.start(70) time.sleep(tf) gpio.cleanup() def led(ff,tf,sf): init() sp = gpio.PWM(solled,500) sap = gpio.PWM(sagled,500) if (sf == 0): sp.start(ff) time.sleep(tf) gpio.cleanup() elif (sf == 1): sap.start(ff) time.sleep(tf) gpio.cleanup() elif (sf == 2): sp.start(ff) sap.start(ff) time.sleep(tf) gpio.cleanup() def kapat(): os.system("pkill -9 -f main.py") def kontrol(): x = random.randrange(1,3) if (x == 1): print ("sagabak") servo(3) time.sleep(0.05) dis = distance('cm') print (dis) if dis < 15: print ("solabak") servo(9) dis = distance('cm') if dis < 15: print ("cik") servo(5.5) geri(2,hiz) else: servo(5.5) geri(0.5,hiz) sol(0.7,hiz) else: servo(5.5) geri(0.5,hiz) sag(0.7,hiz) if (x == 2): print ("solabak") servo(9) time.sleep(0.05) dis = distance('cm') print (dis) if dis < 15: print ("sagabak") servo(3) dis = distance('cm') if dis < 15: print ("cik") servo(5.5) geri(2,hiz) else: servo(5.5) geri(0.5,hiz) sag(0.7,hiz) else: servo(5.5) geri(0.5,hiz) sol(0.7,hiz) print (" ") print ("otonomgorev yazilimi google speech api sesli komutlari ile robotun otonom hareket etmesi icin yazilmistir") print (" ") time.sleep(1) def cizgi(rf): for i in range(0,rf): dis = distance('cm') init() if (gpio.input(23) == 0 and gpio.input(24) == 0): ileri(0.1,hiz) elif (gpio.input(23) == 1 and gpio.input(24) == 0): sol(0.1,hiz) elif (gpio.input(23) == 0 and gpio.input(24) == 1): sag(0.1,hiz) else: pass if dis < 15: print ("cok dar",dis) geri(0.5,hiz) servo(5.5) kontrol() elif dis < 25: print ("dar",dis) else: print ("temiz",dis) dur() aci2 = aci3 = aci4 = 6 aci = 5.5
20.848943
115
0.501522
[ "Apache-2.0" ]
ahmetakif/Voice-Controlled-Raspberry-Pi-Robot
Robotics/src/otonomgorev.py
6,901
Python
def gimme(x): print("It was a %s indeed" % x)
10.4
35
0.538462
[ "Apache-2.0" ]
DavidLeoni/iep
jup-and-py-example/local.py
52
Python
import argparse parser = argparse.ArgumentParser(description="PyTorch implementation of action recognition models") parser.add_argument('--dataset', type=str, choices=['somethingv1','somethingv2','diving48'], default = 'somethingv1') parser.add_argument('--root_path', type = str, default = '../', help = 'root path to video dataset folders') parser.add_argument('--store_name', type=str, default="") # ========================= Model Configs ========================== parser.add_argument('--type', type=str, default="GST",choices=['GST','R3D','S3D', 'I3D'], help = 'type of temporal models, currently support GST,Res3D and S3D') parser.add_argument('--arch', type=str, default="resnet50",choices=['resnet50','resnet101'], help = 'backbone networks, currently only support resnet') parser.add_argument('--num_segments', type=int, default=8) parser.add_argument('--alpha', type=int, default=4, help = 'spatial temporal split for output channels') parser.add_argument('--beta', type=int, default=2, choices=[1,2], help = 'channel splits for input channels, 1 for GST-Large and 2 for GST') # ========================= Learning Configs ========================== parser.add_argument('--epochs', default=70, type=int, metavar='N', help='number of total epochs to run') parser.add_argument('-b', '--batch-size', default=24, type=int, metavar='N', help='mini-batch size') parser.add_argument('--lr', '--learning-rate', default=0.01, type=float, metavar='LR', help='initial learning rate') parser.add_argument('--lr_steps', default=[50, 60], type=float, nargs="+", metavar='LRSteps', help='epochs to decay learning rate by 10') parser.add_argument('--dropout', '--dp', default=0.3, type=float, metavar='dp', help='dropout ratio') parser.add_argument('--warm', default=5, type=float, help='warm up epochs') #========================= Optimizer Configs ========================== parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum') parser.add_argument('--weight_decay', '--wd', default=3e-4, type=float, metavar='W', help='weight decay (default: 3e-4)') parser.add_argument('--clip-gradient', '--gd', default=20, type=float, metavar='W', help='gradient norm clipping (default: 20)') # ========================= Monitor Configs ========================== parser.add_argument('--print-freq', '-p', default=20, type=int, metavar='N', help='print frequency (default: 20)') parser.add_argument('--eval-freq', '-ef', default=1, type=int, metavar='N', help='evaluation frequency (default: 1)') # ========================= Runtime Configs ========================== parser.add_argument('-j', '--workers', default=16, type=int, metavar='N', help='number of data loading workers (default: 16)') parser.add_argument('--resume', default='', type=str, metavar='PATH', help='path to latest checkpoint (default: none)') parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true', help='evaluate model on validation set') parser.add_argument('--start-epoch', default=0, type=int, metavar='N', help='manual epoch number (useful on restarts)') parser.add_argument('--checkpoint_dir',type=str, required=True, help = 'folder to restore checkpoint and training log') # ========================= Added by Qihang ========================== parser.add_argument('--op_code', type=str, default="conv3d", help='op code to use') parser.add_argument('--sparsity-regularization', '-sr', dest='sr', action='store_true', help='train with channel sparsity regularization') parser.add_argument('--s', type=float, default=0.0001, help='scale sparse rate (default: 0.0001)') parser.add_argument('--conv_config', type=str, default='', help='conv config') parser.add_argument('--search', action='store_true', default=False, help='search mode') parser.add_argument('--prune', action='store_true', default=False, help='prune after training') parser.add_argument('--prune_model_path', type=str, default='', help='model to prune') parser.add_argument('--reweight', action='store_true', default=False, help='reweight the prune factor') parser.add_argument('--finetune', default='', type=str, metavar='PATH', help='path to latest checkpoint (default: none)')
62.773333
140
0.594095
[ "MIT" ]
yucornetto/CAKES
opts.py
4,708
Python
from typing import List, Tuple, Optional import aiosqlite from spare.types.blockchain_format.sized_bytes import bytes32 from spare.util.db_wrapper import DBWrapper class WalletInterestedStore: """ Stores coin ids that we are interested in receiving """ db_connection: aiosqlite.Connection db_wrapper: DBWrapper @classmethod async def create(cls, wrapper: DBWrapper): self = cls() self.db_connection = wrapper.db self.db_wrapper = wrapper await self.db_connection.execute("pragma journal_mode=wal") await self.db_connection.execute("pragma synchronous=2") await self.db_connection.execute("CREATE TABLE IF NOT EXISTS interested_coins(coin_name text PRIMARY KEY)") await self.db_connection.execute( "CREATE TABLE IF NOT EXISTS interested_puzzle_hashes(puzzle_hash text PRIMARY KEY, wallet_id integer)" ) await self.db_connection.commit() return self async def _clear_database(self): cursor = await self.db_connection.execute("DELETE FROM puzzle_hashes") await cursor.close() cursor = await self.db_connection.execute("DELETE FROM interested_coins") await cursor.close() await self.db_connection.commit() async def get_interested_coin_ids(self) -> List[bytes32]: cursor = await self.db_connection.execute("SELECT coin_name FROM interested_coins") rows_hex = await cursor.fetchall() return [bytes32(bytes.fromhex(row[0])) for row in rows_hex] async def add_interested_coin_id(self, coin_id: bytes32, in_transaction: bool = False) -> None: if not in_transaction: await self.db_wrapper.lock.acquire() try: cursor = await self.db_connection.execute( "INSERT OR REPLACE INTO interested_coins VALUES (?)", (coin_id.hex(),) ) await cursor.close() finally: if not in_transaction: await self.db_connection.commit() self.db_wrapper.lock.release() async def get_interested_puzzle_hashes(self) -> List[Tuple[bytes32, int]]: cursor = await self.db_connection.execute("SELECT puzzle_hash, wallet_id FROM interested_puzzle_hashes") rows_hex = await cursor.fetchall() return [(bytes32(bytes.fromhex(row[0])), row[1]) for row in rows_hex] async def get_interested_puzzle_hash_wallet_id(self, puzzle_hash: bytes32) -> Optional[int]: cursor = await self.db_connection.execute( "SELECT wallet_id FROM interested_puzzle_hashes WHERE puzzle_hash=?", (puzzle_hash.hex(),) ) row = await cursor.fetchone() if row is None: return None return row[0] async def add_interested_puzzle_hash( self, puzzle_hash: bytes32, wallet_id: int, in_transaction: bool = False ) -> None: if not in_transaction: await self.db_wrapper.lock.acquire() try: cursor = await self.db_connection.execute( "INSERT OR REPLACE INTO interested_puzzle_hashes VALUES (?, ?)", (puzzle_hash.hex(), wallet_id) ) await cursor.close() finally: if not in_transaction: await self.db_connection.commit() self.db_wrapper.lock.release() async def remove_interested_puzzle_hash(self, puzzle_hash: bytes32, in_transaction: bool = False) -> None: if not in_transaction: await self.db_wrapper.lock.acquire() try: cursor = await self.db_connection.execute( "DELETE FROM interested_puzzle_hashes WHERE puzzle_hash=?", (puzzle_hash.hex(),) ) await cursor.close() finally: if not in_transaction: await self.db_connection.commit() self.db_wrapper.lock.release()
38.313725
115
0.651228
[ "Apache-2.0" ]
Spare-Network/spare-blockchain
spare/wallet/wallet_interested_store.py
3,908
Python
""" Client for Yandex.Disk. """ __version__ = '0.0.1'
10.8
23
0.611111
[ "MIT" ]
comalex/ProjectBacup
project_backup/__init__.py
54
Python
# coding=utf-8 # *** WARNING: this file was generated by the Pulumi SDK Generator. *** # *** Do not edit by hand unless you're certain you know what you are doing! *** import warnings import pulumi import pulumi.runtime from typing import Any, Mapping, Optional, Sequence, Union, overload from .. import _utilities from . import outputs from ._inputs import * __all__ = ['StorageInsightConfigArgs', 'StorageInsightConfig'] @pulumi.input_type class StorageInsightConfigArgs: def __init__(__self__, *, resource_group_name: pulumi.Input[str], storage_account: pulumi.Input['StorageAccountArgs'], workspace_name: pulumi.Input[str], containers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, e_tag: Optional[pulumi.Input[str]] = None, storage_insight_name: Optional[pulumi.Input[str]] = None, tables: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None): """ The set of arguments for constructing a StorageInsightConfig resource. :param pulumi.Input[str] resource_group_name: The name of the resource group. The name is case insensitive. :param pulumi.Input['StorageAccountArgs'] storage_account: The storage account connection details :param pulumi.Input[str] workspace_name: The name of the workspace. :param pulumi.Input[Sequence[pulumi.Input[str]]] containers: The names of the blob containers that the workspace should read :param pulumi.Input[str] e_tag: The ETag of the storage insight. :param pulumi.Input[str] storage_insight_name: Name of the storageInsightsConfigs resource :param pulumi.Input[Sequence[pulumi.Input[str]]] tables: The names of the Azure tables that the workspace should read :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags. """ pulumi.set(__self__, "resource_group_name", resource_group_name) pulumi.set(__self__, "storage_account", storage_account) pulumi.set(__self__, "workspace_name", workspace_name) if containers is not None: pulumi.set(__self__, "containers", containers) if e_tag is not None: pulumi.set(__self__, "e_tag", e_tag) if storage_insight_name is not None: pulumi.set(__self__, "storage_insight_name", storage_insight_name) if tables is not None: pulumi.set(__self__, "tables", tables) if tags is not None: pulumi.set(__self__, "tags", tags) @property @pulumi.getter(name="resourceGroupName") def resource_group_name(self) -> pulumi.Input[str]: """ The name of the resource group. The name is case insensitive. """ return pulumi.get(self, "resource_group_name") @resource_group_name.setter def resource_group_name(self, value: pulumi.Input[str]): pulumi.set(self, "resource_group_name", value) @property @pulumi.getter(name="storageAccount") def storage_account(self) -> pulumi.Input['StorageAccountArgs']: """ The storage account connection details """ return pulumi.get(self, "storage_account") @storage_account.setter def storage_account(self, value: pulumi.Input['StorageAccountArgs']): pulumi.set(self, "storage_account", value) @property @pulumi.getter(name="workspaceName") def workspace_name(self) -> pulumi.Input[str]: """ The name of the workspace. """ return pulumi.get(self, "workspace_name") @workspace_name.setter def workspace_name(self, value: pulumi.Input[str]): pulumi.set(self, "workspace_name", value) @property @pulumi.getter def containers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: """ The names of the blob containers that the workspace should read """ return pulumi.get(self, "containers") @containers.setter def containers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): pulumi.set(self, "containers", value) @property @pulumi.getter(name="eTag") def e_tag(self) -> Optional[pulumi.Input[str]]: """ The ETag of the storage insight. """ return pulumi.get(self, "e_tag") @e_tag.setter def e_tag(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "e_tag", value) @property @pulumi.getter(name="storageInsightName") def storage_insight_name(self) -> Optional[pulumi.Input[str]]: """ Name of the storageInsightsConfigs resource """ return pulumi.get(self, "storage_insight_name") @storage_insight_name.setter def storage_insight_name(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "storage_insight_name", value) @property @pulumi.getter def tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: """ The names of the Azure tables that the workspace should read """ return pulumi.get(self, "tables") @tables.setter def tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): pulumi.set(self, "tables", value) @property @pulumi.getter def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: """ Resource tags. """ return pulumi.get(self, "tags") @tags.setter def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): pulumi.set(self, "tags", value) class StorageInsightConfig(pulumi.CustomResource): @overload def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, containers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, e_tag: Optional[pulumi.Input[str]] = None, resource_group_name: Optional[pulumi.Input[str]] = None, storage_account: Optional[pulumi.Input[pulumi.InputType['StorageAccountArgs']]] = None, storage_insight_name: Optional[pulumi.Input[str]] = None, tables: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, workspace_name: Optional[pulumi.Input[str]] = None, __props__=None): """ The top level storage insight resource container. API Version: 2020-08-01. :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[Sequence[pulumi.Input[str]]] containers: The names of the blob containers that the workspace should read :param pulumi.Input[str] e_tag: The ETag of the storage insight. :param pulumi.Input[str] resource_group_name: The name of the resource group. The name is case insensitive. :param pulumi.Input[pulumi.InputType['StorageAccountArgs']] storage_account: The storage account connection details :param pulumi.Input[str] storage_insight_name: Name of the storageInsightsConfigs resource :param pulumi.Input[Sequence[pulumi.Input[str]]] tables: The names of the Azure tables that the workspace should read :param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags. :param pulumi.Input[str] workspace_name: The name of the workspace. """ ... @overload def __init__(__self__, resource_name: str, args: StorageInsightConfigArgs, opts: Optional[pulumi.ResourceOptions] = None): """ The top level storage insight resource container. API Version: 2020-08-01. :param str resource_name: The name of the resource. :param StorageInsightConfigArgs args: The arguments to use to populate this resource's properties. :param pulumi.ResourceOptions opts: Options for the resource. """ ... def __init__(__self__, resource_name: str, *args, **kwargs): resource_args, opts = _utilities.get_resource_args_opts(StorageInsightConfigArgs, pulumi.ResourceOptions, *args, **kwargs) if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, containers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, e_tag: Optional[pulumi.Input[str]] = None, resource_group_name: Optional[pulumi.Input[str]] = None, storage_account: Optional[pulumi.Input[pulumi.InputType['StorageAccountArgs']]] = None, storage_insight_name: Optional[pulumi.Input[str]] = None, tables: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, workspace_name: Optional[pulumi.Input[str]] = None, __props__=None): if opts is None: opts = pulumi.ResourceOptions() if not isinstance(opts, pulumi.ResourceOptions): raise TypeError('Expected resource options to be a ResourceOptions instance') if opts.version is None: opts.version = _utilities.get_version() if opts.id is None: if __props__ is not None: raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') __props__ = StorageInsightConfigArgs.__new__(StorageInsightConfigArgs) __props__.__dict__["containers"] = containers __props__.__dict__["e_tag"] = e_tag if resource_group_name is None and not opts.urn: raise TypeError("Missing required property 'resource_group_name'") __props__.__dict__["resource_group_name"] = resource_group_name if storage_account is None and not opts.urn: raise TypeError("Missing required property 'storage_account'") __props__.__dict__["storage_account"] = storage_account __props__.__dict__["storage_insight_name"] = storage_insight_name __props__.__dict__["tables"] = tables __props__.__dict__["tags"] = tags if workspace_name is None and not opts.urn: raise TypeError("Missing required property 'workspace_name'") __props__.__dict__["workspace_name"] = workspace_name __props__.__dict__["name"] = None __props__.__dict__["status"] = None __props__.__dict__["type"] = None alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-nextgen:operationalinsights:StorageInsightConfig"), pulumi.Alias(type_="azure-native:operationalinsights/v20150320:StorageInsightConfig"), pulumi.Alias(type_="azure-nextgen:operationalinsights/v20150320:StorageInsightConfig"), pulumi.Alias(type_="azure-native:operationalinsights/v20200301preview:StorageInsightConfig"), pulumi.Alias(type_="azure-nextgen:operationalinsights/v20200301preview:StorageInsightConfig"), pulumi.Alias(type_="azure-native:operationalinsights/v20200801:StorageInsightConfig"), pulumi.Alias(type_="azure-nextgen:operationalinsights/v20200801:StorageInsightConfig")]) opts = pulumi.ResourceOptions.merge(opts, alias_opts) super(StorageInsightConfig, __self__).__init__( 'azure-native:operationalinsights:StorageInsightConfig', resource_name, __props__, opts) @staticmethod def get(resource_name: str, id: pulumi.Input[str], opts: Optional[pulumi.ResourceOptions] = None) -> 'StorageInsightConfig': """ Get an existing StorageInsightConfig resource's state with the given name, id, and optional extra properties used to qualify the lookup. :param str resource_name: The unique name of the resulting resource. :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. :param pulumi.ResourceOptions opts: Options for the resource. """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) __props__ = StorageInsightConfigArgs.__new__(StorageInsightConfigArgs) __props__.__dict__["containers"] = None __props__.__dict__["e_tag"] = None __props__.__dict__["name"] = None __props__.__dict__["status"] = None __props__.__dict__["storage_account"] = None __props__.__dict__["tables"] = None __props__.__dict__["tags"] = None __props__.__dict__["type"] = None return StorageInsightConfig(resource_name, opts=opts, __props__=__props__) @property @pulumi.getter def containers(self) -> pulumi.Output[Optional[Sequence[str]]]: """ The names of the blob containers that the workspace should read """ return pulumi.get(self, "containers") @property @pulumi.getter(name="eTag") def e_tag(self) -> pulumi.Output[Optional[str]]: """ The ETag of the storage insight. """ return pulumi.get(self, "e_tag") @property @pulumi.getter def name(self) -> pulumi.Output[str]: """ The name of the resource """ return pulumi.get(self, "name") @property @pulumi.getter def status(self) -> pulumi.Output['outputs.StorageInsightStatusResponse']: """ The status of the storage insight """ return pulumi.get(self, "status") @property @pulumi.getter(name="storageAccount") def storage_account(self) -> pulumi.Output['outputs.StorageAccountResponse']: """ The storage account connection details """ return pulumi.get(self, "storage_account") @property @pulumi.getter def tables(self) -> pulumi.Output[Optional[Sequence[str]]]: """ The names of the Azure tables that the workspace should read """ return pulumi.get(self, "tables") @property @pulumi.getter def tags(self) -> pulumi.Output[Optional[Mapping[str, str]]]: """ Resource tags. """ return pulumi.get(self, "tags") @property @pulumi.getter def type(self) -> pulumi.Output[str]: """ The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" """ return pulumi.get(self, "type")
44.391691
670
0.654412
[ "Apache-2.0" ]
polivbr/pulumi-azure-native
sdk/python/pulumi_azure_native/operationalinsights/storage_insight_config.py
14,960
Python
# This file will consist of some wrapper for using MySQL # It is mainly used for preparing and calling mysql cli import logging from mysql_autoxtrabackup.general_conf import path_config from mysql_autoxtrabackup.general_conf.generalops import GeneralClass from mysql_autoxtrabackup.process_runner.process_runner import ProcessRunner logger = logging.getLogger(__name__) class MySQLClientHelper: def __init__(self, config: str = path_config.config_path_file): self.conf = config # Using Composition instead of Inheritance here options_obj = GeneralClass(config=self.conf) self.mysql_options = options_obj.mysql_options def create_mysql_client_command(self, statement: str) -> str: command_connection = "{} --defaults-file={} -u{} --password={}".format( self.mysql_options.get("mysql"), self.mysql_options.get("mycnf"), self.mysql_options.get("mysql_user"), self.mysql_options.get("mysql_password"), ) command_execute = ' -e "{}"' if self.mysql_options.get("mysql_socket"): command_connection += " --socket={}" new_command = command_connection.format( self.mysql_options.get("mysql_socket") ) else: command_connection += " --host={} --port={}" new_command = command_connection.format( self.mysql_options.get("mysql_host"), self.mysql_options.get("mysql_port"), ) new_command += command_execute return new_command.format(statement) def mysql_run_command(self, statement: str) -> bool: command = self.create_mysql_client_command(statement=statement) return ProcessRunner.run_command(command)
40.409091
79
0.669291
[ "MIT" ]
Big-Ele/MySQL-AutoXtraBackup
mysql_autoxtrabackup/utils/mysql_cli.py
1,778
Python
# Copyright 2018 The Cirq Developers # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import cirq from cirq.contrib.paulistring import ( optimized_circuit, ) def test_optimize(): q0, q1, q2 = cirq.LineQubit.range(3) c_orig = cirq.Circuit.from_ops( cirq.X(q0) ** 0.5, cirq.X(q1), cirq.CZ(q1, q2), cirq.X(q2) ** 0.125, cirq.Z(q1) ** 0.5, cirq.Y(q1) ** 0.5, cirq.CZ(q0, q1), cirq.Z(q1) ** 0.5, cirq.CZ(q1, q2), cirq.Z(q1) ** 0.5, cirq.X(q2) ** 0.875, cirq.CZ(q1, q2), cirq.X(q2) ** 0.125, ) cirq.testing.assert_has_diagram(c_orig, """ 0: ───X^0.5─────────────────────────@─────────────────────────────────── │ 1: ───X───────@───S─────────Y^0.5───@───S───@───S─────────@───────────── │ │ │ 2: ───────────@───X^0.125───────────────────@───X^0.875───@───X^0.125─── """) c_opt = optimized_circuit(c_orig) cirq.testing.assert_allclose_up_to_global_phase( c_orig.to_unitary_matrix(), c_opt.to_unitary_matrix(), atol=1e-7, ) cirq.testing.assert_has_diagram(c_opt, """ 0: ───X^0.5────────────@──────────────────────────────────────── │ 1: ───@───────X^-0.5───@───@────────────────@───Z^-0.5────────── │ │ │ 2: ───@────────────────────@───[X]^-0.875───@───[X]^-0.25───Z─── """) def test_optimize_large_circuit(): q0, q1, q2 = cirq.LineQubit.range(3) c_orig = cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2) c_opt = optimized_circuit(c_orig) cirq.testing.assert_allclose_up_to_global_phase( c_orig.to_unitary_matrix(), c_opt.to_unitary_matrix(), atol=1e-7, ) assert sum(1 for op in c_opt.all_operations() if isinstance(op, cirq.GateOperation) and isinstance(op.gate, cirq.CZPowGate)) == 10 def test_repeat_limit(): q0, q1, q2 = cirq.LineQubit.range(3) c_orig = cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2) c_opt = optimized_circuit(c_orig, repeat=1) cirq.testing.assert_allclose_up_to_global_phase( c_orig.to_unitary_matrix(), c_opt.to_unitary_matrix(), atol=1e-7, ) assert sum(1 for op in c_opt.all_operations() if isinstance(op, cirq.GateOperation) and isinstance(op.gate, cirq.CZPowGate)) >= 10
30.917526
74
0.532844
[ "Apache-2.0" ]
jaywha/Cirq
cirq/contrib/paulistring/optimize_test.py
3,619
Python
# coding=utf-8 # Copyright 2019 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. """Implements 1D cubic Hermite spline interpolation.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import torch def interpolate1d(x, values, tangents): r"""Perform cubic hermite spline interpolation on a 1D spline. The x coordinates of the spline knots are at [0 : 1 : len(values)-1]. Queries outside of the range of the spline are computed using linear extrapolation. See https://en.wikipedia.org/wiki/Cubic_Hermite_spline for details, where "x" corresponds to `x`, "p" corresponds to `values`, and "m" corresponds to `tangents`. Args: x: A tensor of any size of single or double precision floats containing the set of values to be used for interpolation into the spline. values: A vector of single or double precision floats containing the value of each knot of the spline being interpolated into. Must be the same length as `tangents` and the same type as `x`. tangents: A vector of single or double precision floats containing the tangent (derivative) of each knot of the spline being interpolated into. Must be the same length as `values` and the same type as `x`. Returns: The result of interpolating along the spline defined by `values`, and `tangents`, using `x` as the query values. Will be the same length and type as `x`. """ # if x.dtype == 'float64' or torch.as_tensor(x).dtype == torch.float64: # float_dtype = torch.float64 # else: # float_dtype = torch.float32 # x = torch.as_tensor(x, dtype=float_dtype) # values = torch.as_tensor(values, dtype=float_dtype) # tangents = torch.as_tensor(tangents, dtype=float_dtype) assert torch.is_tensor(x) assert torch.is_tensor(values) assert torch.is_tensor(tangents) float_dtype = x.dtype assert values.dtype == float_dtype assert tangents.dtype == float_dtype assert len(values.shape) == 1 assert len(tangents.shape) == 1 assert values.shape[0] == tangents.shape[0] x_lo = torch.floor(torch.clamp(x, torch.as_tensor(0), values.shape[0] - 2)).type(torch.int64) x_hi = x_lo + 1 # Compute the relative distance between each `x` and the knot below it. t = x - x_lo.type(float_dtype) # Compute the cubic hermite expansion of `t`. t_sq = t**2 t_cu = t * t_sq h01 = -2. * t_cu + 3. * t_sq h00 = 1. - h01 h11 = t_cu - t_sq h10 = h11 - t_sq + t # Linearly extrapolate above and below the extents of the spline for all # values. value_before = tangents[0] * t + values[0] value_after = tangents[-1] * (t - 1.) + values[-1] # Cubically interpolate between the knots below and above each query point. neighbor_values_lo = values[x_lo] neighbor_values_hi = values[x_hi] neighbor_tangents_lo = tangents[x_lo] neighbor_tangents_hi = tangents[x_hi] value_mid = ( neighbor_values_lo * h00 + neighbor_values_hi * h01 + neighbor_tangents_lo * h10 + neighbor_tangents_hi * h11) # Return the interpolated or extrapolated values for each query point, # depending on whether or not the query lies within the span of the spline. return torch.where(t < 0., value_before, torch.where(t > 1., value_after, value_mid))
39.346939
79
0.713174
[ "MIT" ]
AaltoVision/automodulator
pioneer/robust_loss_pytorch/cubic_spline.py
3,856
Python
# -*- coding: utf-8 -*- # Copyright 2022 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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. # # Generated code. DO NOT EDIT! # # Snippet for DeleteTrainingPipeline # NOTE: This snippet has been automatically generated for illustrative purposes only. # It may require modifications to work in your environment. # To install the latest published package dependency, execute the following: # python3 -m pip install google-cloud-aiplatform # [START aiplatform_v1_generated_PipelineService_DeleteTrainingPipeline_sync] from google.cloud import aiplatform_v1 def sample_delete_training_pipeline(): # Create a client client = aiplatform_v1.PipelineServiceClient() # Initialize request argument(s) request = aiplatform_v1.DeleteTrainingPipelineRequest( name="name_value", ) # Make the request operation = client.delete_training_pipeline(request=request) print("Waiting for operation to complete...") response = operation.result() # Handle the response print(response) # [END aiplatform_v1_generated_PipelineService_DeleteTrainingPipeline_sync]
32.14
85
0.764779
[ "Apache-2.0" ]
TheMichaelHu/python-aiplatform
samples/generated_samples/aiplatform_v1_generated_pipeline_service_delete_training_pipeline_sync.py
1,607
Python
''' file.readline() 사용해서 csv 파일 열기 ''' # # def my_csv_reader(fn:str, header=True) -> list: # ''' # csv 파일의 데이터 2차원 행렬 형태로 리턴 # # # :param fn: 읽을 파일 이름(예: data\\exam.csv) # :param header: csv파일의 헤더 존재 여부 # :return: csv 파일에서 헤더는 제외한 데이터로 이루어진 2차원 리스트 # ''' # # # if __name__ == '__main__': # # # 작성한 함수들을 테스트 # pass def print_data(data: list) -> None: ''' 2차원 리스트의 내용을 출력 1 10 20 30 40 2 11 21 31 41 ... :param data: 2차원 행렬 형태의 리스트 :return: None ''' readcsv = open('data/exam.csv', mode ='r', encoding='utf-8') line=readcsv.readline() while line: print(line.strip()) line = readcsv.readline() readcsv.close() # def get_sum_mean(data : list, col: int) -> tuple: # ''' # 주어진 2차원 리스트(data)에서 해당 컬럼(col)의 데이터들의 # 총합(sum)과 평균(mean)을 계산해서 리턴 # # :param data: 2차원 행렬 형태의 리스트 # :param col: 컬럼 인덱스(0,1,2,...) # :return: 컬럼 데이터의 합과 평균 # '''
19.18
64
0.542231
[ "MIT" ]
SOOIN-KIM/lab-python
lec07_file/file07.py
1,259
Python
from urllib.parse import urlparse from django.conf import settings from django.db import models from django_extensions.db.fields import UUIDField from pyrabbit.http import HTTPError from django.contrib.sites.models import Site from apps.queues import rabbit class Queue(models.Model): name = models.CharField(max_length=64) vhost = UUIDField(unique=True) is_public = models.BooleanField(default=False) owner = models.ForeignKey(settings.AUTH_USER_MODEL) organizers = models.ManyToManyField( settings.AUTH_USER_MODEL, related_name='organizers', blank=True, null=True, help_text="(Organizers allowed to view this queue when they assign their competition to a queue)" ) def __str__(self): return self.name @property def broker_url(self): # Start with pyamqp://guest:guest@localhost:5672// broker_url_parts = urlparse(settings.BROKER_URL) # Get localhost:5672 host = Site.objects.get_current().domain return "pyamqp://{}:{}@{}:{}/{}".format( self.owner.rabbitmq_username, self.owner.rabbitmq_password, host, settings.RABBITMQ_PORT, self.vhost ) def delete(self, using=None): try: rabbit.delete_vhost(self.vhost) except HTTPError: # Vhost not found or something pass return super(Queue, self).delete(using)
29.32
105
0.656207
[ "Apache-2.0" ]
OhMaley/codalab-competitions
codalab/apps/queues/models.py
1,466
Python
# # This example is again a graph coloring problem. In this case, however, # a stronger object oriented approach is adopted to show how Coopy is # indeed compatible with such practices. # import coopy import random class Node: def __init__(self): self._color = coopy.symbolic_int('c') self._neighbors = set() @property def color(self): return self._color @property def has_valid_connections(self): return coopy.all([self.color != n.color for n in self._neighbors]) def direct_edge_towards(self, other): self._neighbors.add(other) def __repr__(self): return str(self.color) def construct_k_colored_graph(k, n, p): """ Constructs a k colored graph of n nodes in which a pair of nodes shares an edge with probability 0 <= p <= 1. Note: this code is for demonstrative purposes only; the solution for such a problem will not necessarily exist, in which case the concretization process will throw an exception. """ with coopy.scope(): # Instantiate n nodes. nodes = [Node() for i in range(n)] # Connect nodes with probability p. for i in range(n-1): for j in range(i+1,n): a = nodes[i] b = nodes[j] if random.uniform(0,1) < p: a.direct_edge_towards(b) b.direct_edge_towards(a) # Impose restrictions over the nodes. for node in nodes: coopy.any([node.color == i for i in range(k)]).require() node.has_valid_connections.require() # Concretize the graph and return it as a list of nodes. coopy.concretize() return nodes graph = construct_k_colored_graph(3, 10, 0.2) print(graph)
28.109375
74
0.617009
[ "MIT" ]
abarreal/coopy
examples/example-5.py
1,799
Python
# -*- coding: utf-8 -*- # # Electrum - lightweight Dogecoin client # Copyright (C) 2018 The Electrum developers # # Permission is hereby granted, free of charge, to any person # obtaining a copy of this software and associated documentation files # (the "Software"), to deal in the Software without restriction, # including without limitation the rights to use, copy, modify, merge, # publish, distribute, sublicense, and/or sell copies of the Software, # and to permit persons to whom the Software is furnished to do so, # subject to the following conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS # BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN # ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import os import json from .util import inv_dict, all_subclasses from . import bitcoin def read_json(filename, default): path = os.path.join(os.path.dirname(__file__), filename) try: with open(path, 'r') as f: r = json.loads(f.read()) except: r = default return r GIT_REPO_URL = "https://github.com/spesmilo/electrum" GIT_REPO_ISSUES_URL = "https://github.com/spesmilo/electrum/issues" BIP39_WALLET_FORMATS = read_json('bip39_wallet_formats.json', []) class AbstractNet: NET_NAME: str TESTNET: bool WIF_PREFIX: int ADDRTYPE_P2PKH: int ADDRTYPE_P2SH: int SEGWIT_HRP: str # BOLT11_HRP: str GENESIS: str BLOCK_HEIGHT_FIRST_LIGHTNING_CHANNELS: int = 0 BIP44_COIN_TYPE: int LN_REALM_BYTE: int @classmethod def max_checkpoint(cls) -> int: return max(0, len(cls.CHECKPOINTS) * 2016 - 1) @classmethod def rev_genesis_bytes(cls) -> bytes: return bytes.fromhex(bitcoin.rev_hex(cls.GENESIS)) class BitcoinMainnet(AbstractNet): TESTNET = False WIF_PREFIX = 158 ADDRTYPE_P2PKH = 30 ADDRTYPE_P2SH = 22 SEGWIT_HRP = "doge" # GENESIS = "000000000062b72c5e2ceb45fbc8587e807c155b0da735e6483dfba2f0a9c770" GENESIS = "1a91e3dace36e2be3bf030a65679fe821aa1d6ef92e7c9902eb318182c355691" DEFAULT_PORTS = {'t': '50011', 's': '50022'} DEFAULT_SERVERS = read_json('servers.json', {}) CHECKPOINTS = read_json('', []) BLOCK_HEIGHT_FIRST_LIGHTNING_CHANNELS = 200 #BITCOIN_HEADER_PRIV = "02fac398" #BITCOIN_HEADER_PUB = "02facafd" XPRV_HEADERS = { 'standard': 0x02fac398, # xprv # 'p2wpkh-p2sh': 0x02fac398, # yprv # 'p2wsh-p2sh': 0x02fac398, # Yprv # 'p2wpkh': 0x02fac398, # zprv # 'p2wsh': 0x02fac398, # Zprv } XPRV_HEADERS_INV = inv_dict(XPRV_HEADERS) XPUB_HEADERS = { 'standard': 0x02facafd, # xpub # 'p2wpkh-p2sh': 0x02facafd, # ypub # 'p2wsh-p2sh': 0x02facafd, # Ypub # 'p2wpkh': 0x02facafd, # zpub # 'p2wsh': 0x02facafd, # Zpub } XPUB_HEADERS_INV = inv_dict(XPUB_HEADERS) # BIP44_COIN_TYPE = 1 #namecoin # BIP44_COIN_TYPE = 7 # dogecoin BIP44_COIN_TYPE = 1 LN_REALM_BYTE = 0 LN_DNS_SEEDS = [ 'radioblockchain.info', 'radiopool.me', ] AUXPOW_CHAIN_ID = 0x00620004 AUXPOW_START_HEIGHT = 371337 NAME_EXPIRATION = 60 class BitcoinTestnet(AbstractNet): TESTNET = True WIF_PREFIX = 239 ADDRTYPE_P2PKH = 111 ADDRTYPE_P2SH = 196 SEGWIT_HRP = "xdoge" GENESIS = "00000a2ee9363d21e47bc10d5b1e39d4ae4bd950491790e522f90dad86d2d1eb" # GENESIS = "00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008" DEFAULT_PORTS = {'t': '51001', 's': '51002'} DEFAULT_SERVERS = read_json('servers_testnet.json', {}) CHECKPOINTS = read_json('checkpoints_testnet.json', []) XPRV_HEADERS = { 'standard': 0x04358394, # tprv # 'p2wpkh-p2sh': 0x044a4e28, # uprv # 'p2wsh-p2sh': 0x024285b5, # Uprv # 'p2wpkh': 0x045f18bc, # vprv # 'p2wsh': 0x02575048, # Vprv } XPRV_HEADERS_INV = inv_dict(XPRV_HEADERS) XPUB_HEADERS = { 'standard': 0x043587cf, # tpub # 'p2wpkh-p2sh': 0x044a5262, # upub # 'p2wsh-p2sh': 0x024289ef, # Upub # 'p2wpkh': 0x045f1cf6, # vpub # 'p2wsh': 0x02575483, # Vpub } XPUB_HEADERS_INV = inv_dict(XPUB_HEADERS) BIP44_COIN_TYPE = 3 LN_REALM_BYTE = 1 LN_DNS_SEEDS = [] AUXPOW_CHAIN_ID = 0x0062 AUXPOW_START_HEIGHT = 200 NAME_EXPIRATION = 36000 class BitcoinRegtest(BitcoinTestnet): SEGWIT_HRP = "ncrt" GENESIS = "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206" DEFAULT_SERVERS = read_json('servers_regtest.json', {}) CHECKPOINTS = [] LN_DNS_SEEDS = [] NAME_EXPIRATION = 30 class BitcoinSimnet(BitcoinTestnet): WIF_PREFIX = 0x64 ADDRTYPE_P2PKH = 0x3f ADDRTYPE_P2SH = 0x7b SEGWIT_HRP = "sb" GENESIS = "683e86bd5c6d110d91b94b97137ba6bfe02dbbdb8e3dff722a669b5d69d77af6" DEFAULT_SERVERS = read_json('servers_regtest.json', {}) CHECKPOINTS = [] LN_DNS_SEEDS = [] NETS_LIST = tuple(all_subclasses(AbstractNet)) # don't import net directly, import the module instead (so that net is singleton) net = BitcoinMainnet def set_signet(): global net net = BitcoinSignet def set_simnet(): global net net = BitcoinSimnet def set_mainnet(): global net net = BitcoinMainnet def set_testnet(): global net net = BitcoinTestnet def set_regtest(): global net net = BitcoinRegtest
27.890995
81
0.683772
[ "MIT" ]
0xAyanami/electrum
electrum/constants.py
5,885
Python
# Copyright 2015 ETH Zurich # # 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. """ :mod:`socket` --- Low-level socket library ========================================== """ # Stdlib import logging import os import selectors import struct from abc import abstractmethod from errno import EHOSTUNREACH, ENETUNREACH from socket import ( AF_INET, AF_INET6, AF_UNIX, MSG_DONTWAIT, SOCK_DGRAM, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, socket, ) # External from external import ipaddress # SCION from lib.defines import SCION_BUFLEN from lib.dispatcher import reg_dispatcher from lib.errors import SCIONIOError from lib.packet.host_addr import haddr_get_type, haddr_parse_interface from lib.packet.scmp.errors import SCMPUnreachHost, SCMPUnreachNet from lib.util import recv_all from lib.thread import kill_self from lib.types import AddrType class Socket(object): """ Base class for socket wrappers """ @abstractmethod def bind(self, addr, *args, **kwargs): raise NotImplementedError @abstractmethod def send(self, data, dst=None): raise NotImplementedError @abstractmethod def recv(self, block=True): raise NotImplementedError def close(self): # pragma: no cover """ Close the socket. """ self.sock.close() def settimeout(self, timeout): # pragma: no cover prev = self.sock.gettimeout() self.sock.settimeout(timeout) return prev def is_active(self): return True class UDPSocket(Socket): """ Thin wrapper around BSD/POSIX UDP sockets. """ def __init__(self, bind=None, addr_type=AddrType.IPV6, reuse=False): """ Initialize a UDP socket, then call superclass init for socket options and binding. :param tuple bind: Optional tuple of (`str`, `int`, `str`) describing respectively the address and port to bind to, and an optional description. :param addr_type: Socket domain. Must be one of :const:`~lib.types.AddrType.IPV4`, :const:`~lib.types.AddrType.IPV6` (default). :param reuse: Boolean value indicating whether SO_REUSEADDR option should be set. """ assert addr_type in (AddrType.IPV4, AddrType.IPV6) self._addr_type = addr_type af_domain = AF_INET6 if self._addr_type == AddrType.IPV4: af_domain = AF_INET self.sock = socket(af_domain, SOCK_DGRAM) if reuse: self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self.port = None if bind: self.bind(*bind) self.active = True def bind(self, addr, port=0, desc=None): """ Bind socket to the specified address & port. If `addr` is ``None``, the socket will bind to all interfaces. :param str addr: Address to bind to (can be ``None``, see above). :param int port: Port to bind to. :param str desc: Optional purpose of the port. """ if addr is None: addr = "::" if self._addr_type == AddrType.IPV4: addr = "" try: self.sock.bind((addr, port)) except OSError as e: logging.critical("Error binding to [%s]:%s: %s", addr, port, e) kill_self() self.port = self.sock.getsockname()[1] if desc: logging.debug("%s bound to %s:%d", desc, addr, self.port) def send(self, data, dst=None): """ Send data to a specified destination. :param bytes data: Data to send. :param tuple dst: Tuple of (`str`, `int`) describing the destination address and port, respectively. """ try: ret = self.sock.sendto(data, dst) except OSError as e: errno = e.args[0] logging.error("Error sending %dB to %s: %s", len(data), dst, e) if errno == ENETUNREACH: raise SCMPUnreachNet(dst) elif errno == EHOSTUNREACH: raise SCMPUnreachHost(dst) return False if ret != len(data): logging.error("Wanted to send %dB, only sent %dB", len(data), ret) return False return True def recv(self, block=True): """ Read data from socket. :returns: Tuple of (`bytes`, (`str`, `int`) containing the data, and remote host/port respectively. """ flags = 0 if not block: flags = MSG_DONTWAIT while True: try: return self.sock.recvfrom(SCION_BUFLEN, flags) except InterruptedError: pass class ReliableSocket(Socket): """ Wrapper around Unix socket with message framing functionality baked in """ COOKIE = bytes.fromhex("de00ad01be02ef03") COOKIE_LEN = len(COOKIE) def __init__(self, reg=None, bind_ip=(), bind_unix=None, sock=None): """ Initialise a socket of the specified type, and optionally bind it to an address/port. :param tuple reg: Optional tuple of (`SCIONAddr`, `int`, `SVCType`, `bool`) describing respectively the address, port, SVC type, and init value to register with the dispatcher. In sockets that do not connect to the dispatcher, this argument is None. :param tuple bind_ip: Optional tuple of (`SCIONAddr`, `int`) describing the address and port of the bind address. Only needed if the bind address is different from the public address. :param tuple bind_unix: Optional tuple of (`str`, `str`) describing path to bind to, and an optional description. :param sock: Optional socket file object to build instance around. """ self.sock = sock or socket(AF_UNIX, SOCK_STREAM) self.addr = None if reg: addr, port, init, svc = reg self.registered = reg_dispatcher( self, addr, port, bind_ip, init, svc) if bind_unix: self.bind(*bind_unix) self.active = True @classmethod def from_socket(cls, sock): return cls(None, sock=sock) def bind(self, addr, desc=None): self.addr = addr # Use 0666 for socket permissions old_mask = os.umask(0o111) try: self.sock.bind(addr) except OSError as e: logging.critical("Error binding to %s: %s", addr, e) kill_self() os.umask(old_mask) self.sock.listen(5) if desc: logging.debug("%s bound to %s", desc, addr) def accept(self, block=True): prev = self.sock.gettimeout() if not block: self.sock.settimeout(0) try: s = self.sock.accept()[0] except OSError as e: logging.error("error accepting socket: %s", e) return None finally: self.sock.settimeout(prev) return ReliableSocket.from_socket(s) def connect(self, addr): self.sock.connect(addr) def send(self, data, dst=None): """ Send data through the socket. :param bytes data: Data to send. """ if dst: dst_addr, dst_port = dst if isinstance(dst_addr, str): dst_addr = haddr_parse_interface(dst_addr) addr_type = struct.pack("B", dst_addr.TYPE) packed_dst = dst_addr.pack() + struct.pack("!H", dst_port) else: addr_type = struct.pack("B", AddrType.NONE) packed_dst = b"" data_len = struct.pack("!I", len(data)) data = b"".join([self.COOKIE, addr_type, data_len, packed_dst, data]) try: self.sock.sendall(data) return True except OSError as e: logging.error("error in send: %s", e) return False def recv(self, block=True): """ Read data from socket. :returns: bytestring containing received data. """ flags = 0 if not block: flags = MSG_DONTWAIT buf = recv_all(self.sock, self.COOKIE_LEN + 5, flags) if not buf: return None, None cookie, addr_type, packet_len = struct.unpack("!8sBI", buf) if cookie != self.COOKIE: raise SCIONIOError("Dispatcher socket out of sync") port_len = 0 if addr_type != AddrType.NONE: port_len = 2 addr_len = haddr_get_type(addr_type).LEN # We know there is data coming, block here to avoid sync problems. buf = recv_all(self.sock, addr_len + port_len + packet_len, 0) if addr_len > 0: addr = buf[:addr_len] port = struct.unpack("!H", buf[addr_len:addr_len + port_len]) sender = (str(ipaddress.ip_address(addr)), port) else: addr = "" port = 0 sender = (None, None) packet = buf[addr_len + port_len:] return packet, sender def close(self): super().close() if not self.addr: return try: os.unlink(self.addr) except OSError as e: logging.critical("Error unlinking unix socket: %s", e) kill_self() class SocketMgr(object): """ :class:`Socket` manager. """ def __init__(self): # pragma: no cover self._sel = selectors.DefaultSelector() def add(self, sock, callback): # pragma: no cover """ Add new socket. :param UDPSocket sock: UDPSocket to add. """ if not sock.is_active(): return self._sel.register(sock.sock, selectors.EVENT_READ, (sock, callback)) def remove(self, sock): # pragma: no cover """ Remove socket. :param UDPSocket sock: UDPSocket to remove. """ self._sel.unregister(sock.sock) def select_(self, timeout=None): """ Return the set of UDPSockets that have data pending. :param float timeout: Number of seconds to wait for at least one UDPSocket to become ready. ``None`` means wait forever. """ for key, _ in self._sel.select(timeout=timeout): yield key.data def close(self): """ Close all sockets. """ mapping = self._sel.get_map() if mapping: for entry in list(mapping.values()): sock = entry.data[0] self.remove(sock) sock.close() self._sel.close()
31.066298
82
0.577983
[ "Apache-2.0" ]
TpmKranz/netsec-scion
python/lib/socket.py
11,246
Python
#!/bin/python # -*- coding: utf-8 -*- """ | This file is part of the web2py Web Framework | Copyrighted by Massimo Di Pierro <[email protected]> | License: LGPLv3 (http://www.gnu.org/licenses/lgpl.html) Auth, Mail, PluginManager and various utilities ------------------------------------------------ """ import base64 try: import cPickle as pickle except: import pickle import datetime import thread import logging import sys import glob import os import re import time import traceback import smtplib import urllib import urllib2 import Cookie import cStringIO import ConfigParser import email.utils import random from email import MIMEBase, MIMEMultipart, MIMEText, Encoders, Header, message_from_string, Charset from gluon.contenttype import contenttype from gluon.storage import Storage, StorageList, Settings, Messages from gluon.utils import web2py_uuid from gluon.fileutils import read_file, check_credentials from gluon import * from gluon.contrib.autolinks import expand_one from gluon.contrib.markmin.markmin2html import \ replace_at_urls, replace_autolinks, replace_components from pydal.objects import Row, Set, Query import gluon.serializers as serializers Table = DAL.Table Field = DAL.Field try: # try stdlib (Python 2.6) import json as json_parser except ImportError: try: # try external module import simplejson as json_parser except: # fallback to pure-Python module import gluon.contrib.simplejson as json_parser __all__ = ['Mail', 'Auth', 'Recaptcha', 'Crud', 'Service', 'Wiki', 'PluginManager', 'fetch', 'geocode', 'reverse_geocode', 'prettydate'] ### mind there are two loggers here (logger and crud.settings.logger)! logger = logging.getLogger("web2py") DEFAULT = lambda: None def getarg(position, default=None): args = current.request.args if position < 0 and len(args) >= -position: return args[position] elif position >= 0 and len(args) > position: return args[position] else: return default def callback(actions, form, tablename=None): if actions: if tablename and isinstance(actions, dict): actions = actions.get(tablename, []) if not isinstance(actions, (list, tuple)): actions = [actions] [action(form) for action in actions] def validators(*a): b = [] for item in a: if isinstance(item, (list, tuple)): b = b + list(item) else: b.append(item) return b def call_or_redirect(f, *args): if callable(f): redirect(f(*args)) else: redirect(f) def replace_id(url, form): if url: url = url.replace('[id]', str(form.vars.id)) if url[0] == '/' or url[:4] == 'http': return url return URL(url) class Mail(object): """ Class for configuring and sending emails with alternative text / html body, multiple attachments and encryption support Works with SMTP and Google App Engine. Args: server: SMTP server address in address:port notation sender: sender email address login: sender login name and password in login:password notation or None if no authentication is required tls: enables/disables encryption (True by default) In Google App Engine use :: server='gae' For sake of backward compatibility all fields are optional and default to None, however, to be able to send emails at least server and sender must be specified. They are available under following fields:: mail.settings.server mail.settings.sender mail.settings.login mail.settings.timeout = 60 # seconds (default) When server is 'logging', email is logged but not sent (debug mode) Optionally you can use PGP encryption or X509:: mail.settings.cipher_type = None mail.settings.gpg_home = None mail.settings.sign = True mail.settings.sign_passphrase = None mail.settings.encrypt = True mail.settings.x509_sign_keyfile = None mail.settings.x509_sign_certfile = None mail.settings.x509_sign_chainfile = None mail.settings.x509_nocerts = False mail.settings.x509_crypt_certfiles = None cipher_type : None gpg - need a python-pyme package and gpgme lib x509 - smime gpg_home : you can set a GNUPGHOME environment variable to specify home of gnupg sign : sign the message (True or False) sign_passphrase : passphrase for key signing encrypt : encrypt the message (True or False). It defaults to True ... x509 only ... x509_sign_keyfile : the signers private key filename or string containing the key. (PEM format) x509_sign_certfile: the signers certificate filename or string containing the cert. (PEM format) x509_sign_chainfile: sets the optional all-in-one file where you can assemble the certificates of Certification Authorities (CA) which form the certificate chain of email certificate. It can be a string containing the certs to. (PEM format) x509_nocerts : if True then no attached certificate in mail x509_crypt_certfiles: the certificates file or strings to encrypt the messages with can be a file name / string or a list of file names / strings (PEM format) Examples: Create Mail object with authentication data for remote server:: mail = Mail('example.com:25', '[email protected]', 'me:password') Notice for GAE users: attachments have an automatic content_id='attachment-i' where i is progressive number in this way the can be referenced from the HTML as <img src="cid:attachment-0" /> etc. """ class Attachment(MIMEBase.MIMEBase): """ Email attachment Args: payload: path to file or file-like object with read() method filename: name of the attachment stored in message; if set to None, it will be fetched from payload path; file-like object payload must have explicit filename specified content_id: id of the attachment; automatically contained within `<` and `>` content_type: content type of the attachment; if set to None, it will be fetched from filename using gluon.contenttype module encoding: encoding of all strings passed to this function (except attachment body) Content ID is used to identify attachments within the html body; in example, attached image with content ID 'photo' may be used in html message as a source of img tag `<img src="cid:photo" />`. Example:: Create attachment from text file:: attachment = Mail.Attachment('/path/to/file.txt') Content-Type: text/plain MIME-Version: 1.0 Content-Disposition: attachment; filename="file.txt" Content-Transfer-Encoding: base64 SOMEBASE64CONTENT= Create attachment from image file with custom filename and cid:: attachment = Mail.Attachment('/path/to/file.png', filename='photo.png', content_id='photo') Content-Type: image/png MIME-Version: 1.0 Content-Disposition: attachment; filename="photo.png" Content-Id: <photo> Content-Transfer-Encoding: base64 SOMEOTHERBASE64CONTENT= """ def __init__( self, payload, filename=None, content_id=None, content_type=None, encoding='utf-8'): if isinstance(payload, str): if filename is None: filename = os.path.basename(payload) payload = read_file(payload, 'rb') else: if filename is None: raise Exception('Missing attachment name') payload = payload.read() filename = filename.encode(encoding) if content_type is None: content_type = contenttype(filename) self.my_filename = filename self.my_payload = payload MIMEBase.MIMEBase.__init__(self, *content_type.split('/', 1)) self.set_payload(payload) self['Content-Disposition'] = 'attachment; filename="%s"' % filename if not content_id is None: self['Content-Id'] = '<%s>' % content_id.encode(encoding) Encoders.encode_base64(self) def __init__(self, server=None, sender=None, login=None, tls=True): settings = self.settings = Settings() settings.server = server settings.sender = sender settings.login = login settings.tls = tls settings.timeout = 60 # seconds settings.hostname = None settings.ssl = False settings.cipher_type = None settings.gpg_home = None settings.sign = True settings.sign_passphrase = None settings.encrypt = True settings.x509_sign_keyfile = None settings.x509_sign_certfile = None settings.x509_sign_chainfile = None settings.x509_nocerts = False settings.x509_crypt_certfiles = None settings.debug = False settings.lock_keys = True self.result = {} self.error = None def send(self, to, subject='[no subject]', message='[no message]', attachments=None, cc=None, bcc=None, reply_to=None, sender=None, encoding='utf-8', raw=False, headers={}, from_address=None, cipher_type=None, sign=None, sign_passphrase=None, encrypt=None, x509_sign_keyfile=None, x509_sign_chainfile=None, x509_sign_certfile=None, x509_crypt_certfiles=None, x509_nocerts=None ): """ Sends an email using data specified in constructor Args: to: list or tuple of receiver addresses; will also accept single object subject: subject of the email message: email body text; depends on type of passed object: - if 2-list or 2-tuple is passed: first element will be source of plain text while second of html text; - otherwise: object will be the only source of plain text and html source will be set to None If text or html source is: - None: content part will be ignored, - string: content part will be set to it, - file-like object: content part will be fetched from it using it's read() method attachments: list or tuple of Mail.Attachment objects; will also accept single object cc: list or tuple of carbon copy receiver addresses; will also accept single object bcc: list or tuple of blind carbon copy receiver addresses; will also accept single object reply_to: address to which reply should be composed encoding: encoding of all strings passed to this method (including message bodies) headers: dictionary of headers to refine the headers just before sending mail, e.g. `{'X-Mailer' : 'web2py mailer'}` from_address: address to appear in the 'From:' header, this is not the envelope sender. If not specified the sender will be used cipher_type : gpg - need a python-pyme package and gpgme lib x509 - smime gpg_home : you can set a GNUPGHOME environment variable to specify home of gnupg sign : sign the message (True or False) sign_passphrase : passphrase for key signing encrypt : encrypt the message (True or False). It defaults to True. ... x509 only ... x509_sign_keyfile : the signers private key filename or string containing the key. (PEM format) x509_sign_certfile: the signers certificate filename or string containing the cert. (PEM format) x509_sign_chainfile: sets the optional all-in-one file where you can assemble the certificates of Certification Authorities (CA) which form the certificate chain of email certificate. It can be a string containing the certs to. (PEM format) x509_nocerts : if True then no attached certificate in mail x509_crypt_certfiles: the certificates file or strings to encrypt the messages with can be a file name / string or a list of file names / strings (PEM format) Examples: Send plain text message to single address:: mail.send('[email protected]', 'Message subject', 'Plain text body of the message') Send html message to single address:: mail.send('[email protected]', 'Message subject', '<html>Plain text body of the message</html>') Send text and html message to three addresses (two in cc):: mail.send('[email protected]', 'Message subject', ('Plain text body', '<html>html body</html>'), cc=['[email protected]', '[email protected]']) Send html only message with image attachment available from the message by 'photo' content id:: mail.send('[email protected]', 'Message subject', (None, '<html><img src="cid:photo" /></html>'), Mail.Attachment('/path/to/photo.jpg' content_id='photo')) Send email with two attachments and no body text:: mail.send('[email protected], 'Message subject', None, [Mail.Attachment('/path/to/fist.file'), Mail.Attachment('/path/to/second.file')]) Returns: True on success, False on failure. Before return, method updates two object's fields: - self.result: return value of smtplib.SMTP.sendmail() or GAE's mail.send_mail() method - self.error: Exception message or None if above was successful """ # We don't want to use base64 encoding for unicode mail Charset.add_charset('utf-8', Charset.QP, Charset.QP, 'utf-8') def encode_header(key): if [c for c in key if 32 > ord(c) or ord(c) > 127]: return Header.Header(key.encode('utf-8'), 'utf-8') else: return key # encoded or raw text def encoded_or_raw(text): if raw: text = encode_header(text) return text sender = sender or self.settings.sender if not isinstance(self.settings.server, str): raise Exception('Server address not specified') if not isinstance(sender, str): raise Exception('Sender address not specified') if not raw and attachments: # Use multipart/mixed if there is attachments payload_in = MIMEMultipart.MIMEMultipart('mixed') elif raw: # no encoding configuration for raw messages if not isinstance(message, basestring): message = message.read() if isinstance(message, unicode): text = message.encode('utf-8') elif not encoding == 'utf-8': text = message.decode(encoding).encode('utf-8') else: text = message # No charset passed to avoid transport encoding # NOTE: some unicode encoded strings will produce # unreadable mail contents. payload_in = MIMEText.MIMEText(text) if to: if not isinstance(to, (list, tuple)): to = [to] else: raise Exception('Target receiver address not specified') if cc: if not isinstance(cc, (list, tuple)): cc = [cc] if bcc: if not isinstance(bcc, (list, tuple)): bcc = [bcc] if message is None: text = html = None elif isinstance(message, (list, tuple)): text, html = message elif message.strip().startswith('<html') and \ message.strip().endswith('</html>'): text = self.settings.server == 'gae' and message or None html = message else: text = message html = None if (not text is None or not html is None) and (not raw): if not text is None: if not isinstance(text, basestring): text = text.read() if isinstance(text, unicode): text = text.encode('utf-8') elif not encoding == 'utf-8': text = text.decode(encoding).encode('utf-8') if not html is None: if not isinstance(html, basestring): html = html.read() if isinstance(html, unicode): html = html.encode('utf-8') elif not encoding == 'utf-8': html = html.decode(encoding).encode('utf-8') # Construct mime part only if needed if text is not None and html: # We have text and html we need multipart/alternative attachment = MIMEMultipart.MIMEMultipart('alternative') attachment.attach(MIMEText.MIMEText(text, _charset='utf-8')) attachment.attach( MIMEText.MIMEText(html, 'html', _charset='utf-8')) elif text is not None: attachment = MIMEText.MIMEText(text, _charset='utf-8') elif html: attachment = \ MIMEText.MIMEText(html, 'html', _charset='utf-8') if attachments: # If there is attachments put text and html into # multipart/mixed payload_in.attach(attachment) else: # No attachments no multipart/mixed payload_in = attachment if (attachments is None) or raw: pass elif isinstance(attachments, (list, tuple)): for attachment in attachments: payload_in.attach(attachment) else: payload_in.attach(attachments) ####################################################### # CIPHER # ####################################################### cipher_type = cipher_type or self.settings.cipher_type sign = sign if sign != None else self.settings.sign sign_passphrase = sign_passphrase or self.settings.sign_passphrase encrypt = encrypt if encrypt != None else self.settings.encrypt ####################################################### # GPGME # ####################################################### if cipher_type == 'gpg': if self.settings.gpg_home: # Set GNUPGHOME environment variable to set home of gnupg import os os.environ['GNUPGHOME'] = self.settings.gpg_home if not sign and not encrypt: self.error = "No sign and no encrypt is set but cipher type to gpg" return False # need a python-pyme package and gpgme lib from pyme import core, errors from pyme.constants.sig import mode ############################################ # sign # ############################################ if sign: import string core.check_version(None) pin = string.replace(payload_in.as_string(), '\n', '\r\n') plain = core.Data(pin) sig = core.Data() c = core.Context() c.set_armor(1) c.signers_clear() # search for signing key for From: for sigkey in c.op_keylist_all(sender, 1): if sigkey.can_sign: c.signers_add(sigkey) if not c.signers_enum(0): self.error = 'No key for signing [%s]' % sender return False c.set_passphrase_cb(lambda x, y, z: sign_passphrase) try: # make a signature c.op_sign(plain, sig, mode.DETACH) sig.seek(0, 0) # make it part of the email payload = MIMEMultipart.MIMEMultipart('signed', boundary=None, _subparts=None, **dict( micalg="pgp-sha1", protocol="application/pgp-signature")) # insert the origin payload payload.attach(payload_in) # insert the detached signature p = MIMEBase.MIMEBase("application", 'pgp-signature') p.set_payload(sig.read()) payload.attach(p) # it's just a trick to handle the no encryption case payload_in = payload except errors.GPGMEError, ex: self.error = "GPG error: %s" % ex.getstring() return False ############################################ # encrypt # ############################################ if encrypt: core.check_version(None) plain = core.Data(payload_in.as_string()) cipher = core.Data() c = core.Context() c.set_armor(1) # collect the public keys for encryption recipients = [] rec = to[:] if cc: rec.extend(cc) if bcc: rec.extend(bcc) for addr in rec: c.op_keylist_start(addr, 0) r = c.op_keylist_next() if r is None: self.error = 'No key for [%s]' % addr return False recipients.append(r) try: # make the encryption c.op_encrypt(recipients, 1, plain, cipher) cipher.seek(0, 0) # make it a part of the email payload = MIMEMultipart.MIMEMultipart('encrypted', boundary=None, _subparts=None, **dict(protocol="application/pgp-encrypted")) p = MIMEBase.MIMEBase("application", 'pgp-encrypted') p.set_payload("Version: 1\r\n") payload.attach(p) p = MIMEBase.MIMEBase("application", 'octet-stream') p.set_payload(cipher.read()) payload.attach(p) except errors.GPGMEError, ex: self.error = "GPG error: %s" % ex.getstring() return False ####################################################### # X.509 # ####################################################### elif cipher_type == 'x509': if not sign and not encrypt: self.error = "No sign and no encrypt is set but cipher type to x509" return False import os x509_sign_keyfile = x509_sign_keyfile or\ self.settings.x509_sign_keyfile x509_sign_chainfile = x509_sign_chainfile or\ self.settings.x509_sign_chainfile x509_sign_certfile = x509_sign_certfile or\ self.settings.x509_sign_certfile or\ x509_sign_keyfile or\ self.settings.x509_sign_certfile # crypt certfiles could be a string or a list x509_crypt_certfiles = x509_crypt_certfiles or\ self.settings.x509_crypt_certfiles x509_nocerts = x509_nocerts or\ self.settings.x509_nocerts # need m2crypto try: from M2Crypto import BIO, SMIME, X509 except Exception, e: self.error = "Can't load M2Crypto module" return False msg_bio = BIO.MemoryBuffer(payload_in.as_string()) s = SMIME.SMIME() # SIGN if sign: # key for signing try: keyfile_bio = BIO.openfile(x509_sign_keyfile)\ if os.path.isfile(x509_sign_keyfile)\ else BIO.MemoryBuffer(x509_sign_keyfile) sign_certfile_bio = BIO.openfile(x509_sign_certfile)\ if os.path.isfile(x509_sign_certfile)\ else BIO.MemoryBuffer(x509_sign_certfile) s.load_key_bio(keyfile_bio, sign_certfile_bio, callback=lambda x: sign_passphrase) if x509_sign_chainfile: sk = X509.X509_Stack() chain = X509.load_cert(x509_sign_chainfile)\ if os.path.isfile(x509_sign_chainfile)\ else X509.load_cert_string(x509_sign_chainfile) sk.push(chain) s.set_x509_stack(sk) except Exception, e: self.error = "Something went wrong on certificate / private key loading: <%s>" % str(e) return False try: if x509_nocerts: flags = SMIME.PKCS7_NOCERTS else: flags = 0 if not encrypt: flags += SMIME.PKCS7_DETACHED p7 = s.sign(msg_bio, flags=flags) msg_bio = BIO.MemoryBuffer(payload_in.as_string( )) # Recreate coz sign() has consumed it. except Exception, e: self.error = "Something went wrong on signing: <%s> %s" % ( str(e), str(flags)) return False # ENCRYPT if encrypt: try: sk = X509.X509_Stack() if not isinstance(x509_crypt_certfiles, (list, tuple)): x509_crypt_certfiles = [x509_crypt_certfiles] # make an encryption cert's stack for crypt_certfile in x509_crypt_certfiles: certfile = X509.load_cert(crypt_certfile)\ if os.path.isfile(crypt_certfile)\ else X509.load_cert_string(crypt_certfile) sk.push(certfile) s.set_x509_stack(sk) s.set_cipher(SMIME.Cipher('des_ede3_cbc')) tmp_bio = BIO.MemoryBuffer() if sign: s.write(tmp_bio, p7) else: tmp_bio.write(payload_in.as_string()) p7 = s.encrypt(tmp_bio) except Exception, e: self.error = "Something went wrong on encrypting: <%s>" % str(e) return False # Final stage in sign and encryption out = BIO.MemoryBuffer() if encrypt: s.write(out, p7) else: if sign: s.write(out, p7, msg_bio, SMIME.PKCS7_DETACHED) else: out.write('\r\n') out.write(payload_in.as_string()) out.close() st = str(out.read()) payload = message_from_string(st) else: # no cryptography process as usual payload = payload_in if from_address: payload['From'] = encoded_or_raw(from_address.decode(encoding)) else: payload['From'] = encoded_or_raw(sender.decode(encoding)) origTo = to[:] if to: payload['To'] = encoded_or_raw(', '.join(to).decode(encoding)) if reply_to: payload['Reply-To'] = encoded_or_raw(reply_to.decode(encoding)) if cc: payload['Cc'] = encoded_or_raw(', '.join(cc).decode(encoding)) to.extend(cc) if bcc: to.extend(bcc) payload['Subject'] = encoded_or_raw(subject.decode(encoding)) payload['Date'] = email.utils.formatdate() for k, v in headers.iteritems(): payload[k] = encoded_or_raw(v.decode(encoding)) result = {} try: if self.settings.server == 'logging': logger.warn('email not sent\n%s\nFrom: %s\nTo: %s\nSubject: %s\n\n%s\n%s\n' % ('-' * 40, sender, ', '.join(to), subject, text or html, '-' * 40)) elif self.settings.server == 'gae': xcc = dict() if cc: xcc['cc'] = cc if bcc: xcc['bcc'] = bcc if reply_to: xcc['reply_to'] = reply_to from google.appengine.api import mail attachments = attachments and [mail.Attachment( a.my_filename, a.my_payload, contebt_id='<attachment-%s>' % k ) for k,a in enumerate(attachments) if not raw] if attachments: result = mail.send_mail( sender=sender, to=origTo, subject=subject, body=text, html=html, attachments=attachments, **xcc) elif html and (not raw): result = mail.send_mail( sender=sender, to=origTo, subject=subject, body=text, html=html, **xcc) else: result = mail.send_mail( sender=sender, to=origTo, subject=subject, body=text, **xcc) else: smtp_args = self.settings.server.split(':') kwargs = dict(timeout=self.settings.timeout) if self.settings.ssl: server = smtplib.SMTP_SSL(*smtp_args, **kwargs) else: server = smtplib.SMTP(*smtp_args, **kwargs) if self.settings.tls and not self.settings.ssl: server.ehlo(self.settings.hostname) server.starttls() server.ehlo(self.settings.hostname) if self.settings.login: server.login(*self.settings.login.split(':', 1)) result = server.sendmail( sender, to, payload.as_string()) server.quit() except Exception, e: logger.warn('Mail.send failure:%s' % e) self.result = result self.error = e return False self.result = result self.error = None return True class Recaptcha(DIV): """ Examples: Use as:: form = FORM(Recaptcha(public_key='...',private_key='...')) or:: form = SQLFORM(...) form.append(Recaptcha(public_key='...',private_key='...')) """ API_SSL_SERVER = 'https://www.google.com/recaptcha/api' API_SERVER = 'http://www.google.com/recaptcha/api' VERIFY_SERVER = 'http://www.google.com/recaptcha/api/verify' def __init__(self, request=None, public_key='', private_key='', use_ssl=False, error=None, error_message='invalid', label='Verify:', options='', comment='', ajax=False ): request = request or current.request self.request_vars = request and request.vars or current.request.vars self.remote_addr = request.env.remote_addr self.public_key = public_key self.private_key = private_key self.use_ssl = use_ssl self.error = error self.errors = Storage() self.error_message = error_message self.components = [] self.attributes = {} self.label = label self.options = options self.comment = comment self.ajax = ajax def _validate(self): # for local testing: recaptcha_challenge_field = \ self.request_vars.recaptcha_challenge_field recaptcha_response_field = \ self.request_vars.recaptcha_response_field private_key = self.private_key remoteip = self.remote_addr if not (recaptcha_response_field and recaptcha_challenge_field and len(recaptcha_response_field) and len(recaptcha_challenge_field)): self.errors['captcha'] = self.error_message return False params = urllib.urlencode({ 'privatekey': private_key, 'remoteip': remoteip, 'challenge': recaptcha_challenge_field, 'response': recaptcha_response_field, }) request = urllib2.Request( url=self.VERIFY_SERVER, data=params, headers={'Content-type': 'application/x-www-form-urlencoded', 'User-agent': 'reCAPTCHA Python'}) httpresp = urllib2.urlopen(request) return_values = httpresp.read().splitlines() httpresp.close() return_code = return_values[0] if return_code == 'true': del self.request_vars.recaptcha_challenge_field del self.request_vars.recaptcha_response_field self.request_vars.captcha = '' return True else: # In case we get an error code, store it so we can get an error message # from the /api/challenge URL as described in the reCAPTCHA api docs. self.error = return_values[1] self.errors['captcha'] = self.error_message return False def xml(self): public_key = self.public_key use_ssl = self.use_ssl error_param = '' if self.error: error_param = '&error=%s' % self.error if use_ssl: server = self.API_SSL_SERVER else: server = self.API_SERVER if not self.ajax: captcha = DIV( SCRIPT("var RecaptchaOptions = {%s};" % self.options), SCRIPT(_type="text/javascript", _src="%s/challenge?k=%s%s" % (server, public_key, error_param)), TAG.noscript( IFRAME( _src="%s/noscript?k=%s%s" % ( server, public_key, error_param), _height="300", _width="500", _frameborder="0"), BR(), INPUT( _type='hidden', _name='recaptcha_response_field', _value='manual_challenge')), _id='recaptcha') else: #use Google's ajax interface, needed for LOADed components url_recaptcha_js = "%s/js/recaptcha_ajax.js" % server RecaptchaOptions = "var RecaptchaOptions = {%s}" % self.options script = """%(options)s; jQuery.getScript('%(url)s',function() { Recaptcha.create('%(public_key)s', 'recaptcha',jQuery.extend(RecaptchaOptions,{'callback':Recaptcha.focus_response_field})) }) """ % ({'options': RecaptchaOptions, 'url': url_recaptcha_js, 'public_key': public_key}) captcha = DIV( SCRIPT( script, _type="text/javascript", ), TAG.noscript( IFRAME( _src="%s/noscript?k=%s%s" % ( server, public_key, error_param), _height="300", _width="500", _frameborder="0"), BR(), INPUT( _type='hidden', _name='recaptcha_response_field', _value='manual_challenge')), _id='recaptcha') if not self.errors.captcha: return XML(captcha).xml() else: captcha.append(DIV(self.errors['captcha'], _class='error')) return XML(captcha).xml() # this should only be used for catcha and perhaps not even for that def addrow(form, a, b, c, style, _id, position=-1): if style == "divs": form[0].insert(position, DIV(DIV(LABEL(a), _class='w2p_fl'), DIV(b, _class='w2p_fw'), DIV(c, _class='w2p_fc'), _id=_id)) elif style == "table2cols": form[0].insert(position, TR(TD(LABEL(a), _class='w2p_fl'), TD(c, _class='w2p_fc'))) form[0].insert(position + 1, TR(TD(b, _class='w2p_fw'), _colspan=2, _id=_id)) elif style == "ul": form[0].insert(position, LI(DIV(LABEL(a), _class='w2p_fl'), DIV(b, _class='w2p_fw'), DIV(c, _class='w2p_fc'), _id=_id)) elif style == "bootstrap": form[0].insert(position, DIV(LABEL(a, _class='control-label'), DIV(b, SPAN(c, _class='inline-help'), _class='controls'), _class='control-group', _id=_id)) else: form[0].insert(position, TR(TD(LABEL(a), _class='w2p_fl'), TD(b, _class='w2p_fw'), TD(c, _class='w2p_fc'), _id=_id)) class Auth(object): default_settings = dict( hideerror=False, password_min_length=4, cas_maps=None, reset_password_requires_verification=False, registration_requires_verification=False, registration_requires_approval=False, login_after_registration=False, login_after_password_change=True, alternate_requires_registration=False, create_user_groups="user_%(id)s", everybody_group_id=None, manager_actions={}, auth_manager_role=None, two_factor_authentication_group = None, login_captcha=None, register_captcha=None, pre_registration_div=None, retrieve_username_captcha=None, retrieve_password_captcha=None, captcha=None, prevent_open_redirect_attacks=True, prevent_password_reset_attacks=True, expiration=3600, # one hour long_expiration=3600 * 30 * 24, # one month remember_me_form=True, allow_basic_login=False, allow_basic_login_only=False, on_failed_authentication=lambda x: redirect(x), formstyle=None, label_separator=None, logging_enabled = True, allow_delete_accounts=False, password_field='password', table_user_name='auth_user', table_group_name='auth_group', table_membership_name='auth_membership', table_permission_name='auth_permission', table_event_name='auth_event', table_cas_name='auth_cas', table_user=None, table_group=None, table_membership=None, table_permission=None, table_event=None, table_cas=None, showid=False, use_username=False, login_email_validate=True, login_userfield=None, multi_login=False, logout_onlogout=None, register_fields=None, register_verify_password=True, profile_fields=None, email_case_sensitive=True, username_case_sensitive=True, update_fields=['email'], ondelete="CASCADE", client_side=True, renew_session_onlogin=True, renew_session_onlogout=True, keep_session_onlogin=True, keep_session_onlogout=False, wiki=Settings(), ) # ## these are messages that can be customized default_messages = dict( login_button='Log In', register_button='Sign Up', password_reset_button='Request reset password', password_change_button='Change password', profile_save_button='Apply changes', submit_button='Submit', verify_password='Verify Password', delete_label='Check to delete', function_disabled='Function disabled', access_denied='Insufficient privileges', registration_verifying='Registration needs verification', registration_pending='Registration is pending approval', email_taken='This email already has an account', invalid_username='Invalid username', username_taken='Username already taken', login_disabled='Login disabled by administrator', logged_in='Logged in', email_sent='Email sent', unable_to_send_email='Unable to send email', email_verified='Email verified', logged_out='Logged out', registration_successful='Registration successful', invalid_email='Invalid email', unable_send_email='Unable to send email', invalid_login='Invalid login', invalid_user='Invalid user', invalid_password='Invalid password', is_empty="Cannot be empty", mismatched_password="Password fields don't match", verify_email='Welcome %(username)s! Click on the link %(link)s to verify your email', verify_email_subject='Email verification', username_sent='Your username was emailed to you', new_password_sent='A new password was emailed to you', password_changed='Password changed', retrieve_username='Your username is: %(username)s', retrieve_username_subject='Username retrieve', retrieve_password='Your password is: %(password)s', retrieve_password_subject='Password retrieve', reset_password='Click on the link %(link)s to reset your password', reset_password_subject='Password reset', invalid_reset_password='Invalid reset password', profile_updated='Profile updated', new_password='New password', old_password='Old password', group_description='Group uniquely assigned to user %(id)s', register_log='User %(id)s Registered', login_log='User %(id)s Logged-in', login_failed_log=None, logout_log='User %(id)s Logged-out', profile_log='User %(id)s Profile updated', verify_email_log='User %(id)s Verification email sent', retrieve_username_log='User %(id)s Username retrieved', retrieve_password_log='User %(id)s Password retrieved', reset_password_log='User %(id)s Password reset', change_password_log='User %(id)s Password changed', add_group_log='Group %(group_id)s created', del_group_log='Group %(group_id)s deleted', add_membership_log=None, del_membership_log=None, has_membership_log=None, add_permission_log=None, del_permission_log=None, has_permission_log=None, impersonate_log='User %(id)s is impersonating %(other_id)s', label_first_name='First name', label_last_name='Last name', label_username='Username', label_email='E-mail', label_password='Password', label_registration_key='Registration key', label_reset_password_key='Reset Password key', label_registration_id='Registration identifier', label_role='Role', label_description='Description', label_user_id='User ID', label_group_id='Group ID', label_name='Name', label_table_name='Object or table name', label_record_id='Record ID', label_time_stamp='Timestamp', label_client_ip='Client IP', label_origin='Origin', label_remember_me="Remember me (for 30 days)", verify_password_comment='please input your password again', ) """ Class for authentication, authorization, role based access control. Includes: - registration and profile - login and logout - username and password retrieval - event logging - role creation and assignment - user defined group/role based permission Args: environment: is there for legacy but unused (awful) db: has to be the database where to create tables for authentication mailer: `Mail(...)` or None (no mailer) or True (make a mailer) hmac_key: can be a hmac_key or hmac_key=Auth.get_or_create_key() controller: (where is the user action?) cas_provider: (delegate authentication to the URL, CAS2) Authentication Example:: from gluon.contrib.utils import * mail=Mail() mail.settings.server='smtp.gmail.com:587' mail.settings.sender='[email protected]' mail.settings.login='username:password' auth=Auth(db) auth.settings.mailer=mail # auth.settings....=... auth.define_tables() def authentication(): return dict(form=auth()) Exposes: - `http://.../{application}/{controller}/authentication/login` - `http://.../{application}/{controller}/authentication/logout` - `http://.../{application}/{controller}/authentication/register` - `http://.../{application}/{controller}/authentication/verify_email` - `http://.../{application}/{controller}/authentication/retrieve_username` - `http://.../{application}/{controller}/authentication/retrieve_password` - `http://.../{application}/{controller}/authentication/reset_password` - `http://.../{application}/{controller}/authentication/profile` - `http://.../{application}/{controller}/authentication/change_password` On registration a group with role=new_user.id is created and user is given membership of this group. You can create a group with:: group_id=auth.add_group('Manager', 'can access the manage action') auth.add_permission(group_id, 'access to manage') Here "access to manage" is just a user defined string. You can give access to a user:: auth.add_membership(group_id, user_id) If user id is omitted, the logged in user is assumed Then you can decorate any action:: @auth.requires_permission('access to manage') def manage(): return dict() You can restrict a permission to a specific table:: auth.add_permission(group_id, 'edit', db.sometable) @auth.requires_permission('edit', db.sometable) Or to a specific record:: auth.add_permission(group_id, 'edit', db.sometable, 45) @auth.requires_permission('edit', db.sometable, 45) If authorization is not granted calls:: auth.settings.on_failed_authorization Other options:: auth.settings.mailer=None auth.settings.expiration=3600 # seconds ... ### these are messages that can be customized ... """ @staticmethod def get_or_create_key(filename=None, alg='sha512'): request = current.request if not filename: filename = os.path.join(request.folder, 'private', 'auth.key') if os.path.exists(filename): key = open(filename, 'r').read().strip() else: key = alg + ':' + web2py_uuid() open(filename, 'w').write(key) return key def url(self, f=None, args=None, vars=None, scheme=False): if args is None: args = [] if vars is None: vars = {} return URL(c=self.settings.controller, f=f, args=args, vars=vars, scheme=scheme) def here(self): return URL(args=current.request.args, vars=current.request.get_vars) def __init__(self, environment=None, db=None, mailer=True, hmac_key=None, controller='default', function='user', cas_provider=None, signature=True, secure=False, csrf_prevention=True, propagate_extension=None, url_index=None): ## next two lines for backward compatibility if not db and environment and isinstance(environment, DAL): db = environment self.db = db self.environment = current self.csrf_prevention = csrf_prevention request = current.request session = current.session auth = session.auth self.user_groups = auth and auth.user_groups or {} if secure: request.requires_https() now = request.now # if we have auth info # if not expired it, used it # if expired, clear the session # else, only clear auth info in the session if auth: delta = datetime.timedelta(days=0, seconds=auth.expiration) if auth.last_visit and auth.last_visit + delta > now: self.user = auth.user # this is a trick to speed up sessions to avoid many writes if (now - auth.last_visit).seconds > (auth.expiration / 10): auth.last_visit = request.now else: self.user = None if session.auth: del session.auth session.renew(clear_session=True) else: self.user = None if session.auth: del session.auth # ## what happens after login? url_index = url_index or URL(controller, 'index') url_login = URL(controller, function, args='login', extension = propagate_extension) # ## what happens after registration? settings = self.settings = Settings() settings.update(Auth.default_settings) settings.update( cas_domains=[request.env.http_host], cas_provider=cas_provider, cas_actions=dict(login='login', validate='validate', servicevalidate='serviceValidate', proxyvalidate='proxyValidate', logout='logout'), extra_fields={}, actions_disabled=[], controller=controller, function=function, login_url=url_login, logged_url=URL(controller, function, args='profile'), download_url=URL(controller, 'download'), mailer=(mailer is True) and Mail() or mailer, on_failed_authorization = URL(controller, function, args='not_authorized'), login_next = url_index, login_onvalidation = [], login_onaccept = [], login_onfail = [], login_methods = [self], login_form = self, logout_next = url_index, logout_onlogout = None, register_next = url_index, register_onvalidation = [], register_onaccept = [], verify_email_next = url_login, verify_email_onaccept = [], profile_next = url_index, profile_onvalidation = [], profile_onaccept = [], retrieve_username_next = url_index, retrieve_password_next = url_index, request_reset_password_next = url_login, reset_password_next = url_index, change_password_next = url_index, change_password_onvalidation = [], change_password_onaccept = [], retrieve_password_onvalidation = [], reset_password_onvalidation = [], reset_password_onaccept = [], hmac_key = hmac_key, formstyle = current.response.formstyle, label_separator = current.response.form_label_separator ) settings.lock_keys = True # ## these are messages that can be customized messages = self.messages = Messages(current.T) messages.update(Auth.default_messages) messages.update(ajax_failed_authentication= DIV(H4('NOT AUTHORIZED'), 'Please ', A('login', _href=self.settings.login_url + ('?_next=' + urllib.quote(current.request.env.http_web2py_component_location)) if current.request.env.http_web2py_component_location else ''), ' to view this content.', _class='not-authorized alert alert-block')) messages.lock_keys = True # for "remember me" option response = current.response if auth and auth.remember_me: # when user wants to be logged in for longer response.session_cookie_expires = auth.expiration if signature: self.define_signature() else: self.signature = None def get_vars_next(self): next = current.request.vars._next if isinstance(next, (list, tuple)): next = next[0] return next def _get_user_id(self): """accessor for auth.user_id""" return self.user and self.user.id or None user_id = property(_get_user_id, doc="user.id or None") def table_user(self): return self.db[self.settings.table_user_name] def table_group(self): return self.db[self.settings.table_group_name] def table_membership(self): return self.db[self.settings.table_membership_name] def table_permission(self): return self.db[self.settings.table_permission_name] def table_event(self): return self.db[self.settings.table_event_name] def table_cas(self): return self.db[self.settings.table_cas_name] def _HTTP(self, *a, **b): """ only used in lambda: self._HTTP(404) """ raise HTTP(*a, **b) def __call__(self): """ Example: Use as:: def authentication(): return dict(form=auth()) """ request = current.request args = request.args if not args: redirect(self.url(args='login', vars=request.vars)) elif args[0] in self.settings.actions_disabled: raise HTTP(404) if args[0] in ('login', 'logout', 'register', 'verify_email', 'retrieve_username', 'retrieve_password', 'reset_password', 'request_reset_password', 'change_password', 'profile', 'groups', 'impersonate', 'not_authorized'): if len(request.args) >= 2 and args[0] == 'impersonate': return getattr(self, args[0])(request.args[1]) else: return getattr(self, args[0])() elif args[0] == 'cas' and not self.settings.cas_provider: if args(1) == self.settings.cas_actions['login']: return self.cas_login(version=2) elif args(1) == self.settings.cas_actions['validate']: return self.cas_validate(version=1) elif args(1) == self.settings.cas_actions['servicevalidate']: return self.cas_validate(version=2, proxy=False) elif args(1) == self.settings.cas_actions['proxyvalidate']: return self.cas_validate(version=2, proxy=True) elif args(1) == self.settings.cas_actions['logout']: return self.logout(next=request.vars.service or DEFAULT) else: raise HTTP(404) def navbar(self, prefix='Welcome', action=None, separators=(' [ ', ' | ', ' ] '), user_identifier=DEFAULT, referrer_actions=DEFAULT, mode='default'): """ Navbar with support for more templates This uses some code from the old navbar. Args: mode: see options for list of """ items = [] # Hold all menu items in a list self.bar = '' # The final T = current.T referrer_actions = [] if not referrer_actions else referrer_actions if not action: action = self.url(self.settings.function) request = current.request if URL() == action: next = '' else: next = '?_next=' + urllib.quote(URL(args=request.args, vars=request.get_vars)) href = lambda function: '%s/%s%s' % (action, function, next if referrer_actions is DEFAULT or function in referrer_actions else '') if isinstance(prefix, str): prefix = T(prefix) if prefix: prefix = prefix.strip() + ' ' def Anr(*a, **b): b['_rel'] = 'nofollow' return A(*a, **b) if self.user_id: # User is logged in logout_next = self.settings.logout_next items.append({'name': T('Log Out'), 'href': '%s/logout?_next=%s' % (action, urllib.quote( logout_next)), 'icon': 'icon-off'}) if not 'profile' in self.settings.actions_disabled: items.append({'name': T('Profile'), 'href': href('profile'), 'icon': 'icon-user'}) if not 'change_password' in self.settings.actions_disabled: items.append({'name': T('Password'), 'href': href('change_password'), 'icon': 'icon-lock'}) if user_identifier is DEFAULT: user_identifier = '%(first_name)s' if callable(user_identifier): user_identifier = user_identifier(self.user) elif ((isinstance(user_identifier, str) or type(user_identifier).__name__ == 'lazyT') and re.search(r'%\(.+\)s', user_identifier)): user_identifier = user_identifier % self.user if not user_identifier: user_identifier = '' else: # User is not logged in items.append({'name': T('Log In'), 'href': href('login'), 'icon': 'icon-off'}) if not 'register' in self.settings.actions_disabled: items.append({'name': T('Sign Up'), 'href': href('register'), 'icon': 'icon-user'}) if not 'request_reset_password' in self.settings.actions_disabled: items.append({'name': T('Lost password?'), 'href': href('request_reset_password'), 'icon': 'icon-lock'}) if (self.settings.use_username and not 'retrieve_username' in self.settings.actions_disabled): items.append({'name': T('Forgot username?'), 'href': href('retrieve_username'), 'icon': 'icon-edit'}) def menu(): # For inclusion in MENU self.bar = [(items[0]['name'], False, items[0]['href'], [])] del items[0] for item in items: self.bar[0][3].append((item['name'], False, item['href'])) def bootstrap3(): # Default web2py scaffolding def rename(icon): return icon+' '+icon.replace('icon', 'glyphicon') self.bar = UL(LI(Anr(I(_class=rename('icon '+items[0]['icon'])), ' ' + items[0]['name'], _href=items[0]['href'])), _class='dropdown-menu') del items[0] for item in items: self.bar.insert(-1, LI(Anr(I(_class=rename('icon '+item['icon'])), ' ' + item['name'], _href=item['href']))) self.bar.insert(-1, LI('', _class='divider')) if self.user_id: self.bar = LI(Anr(prefix, user_identifier, _href='#', _class="dropdown-toggle", data={'toggle': 'dropdown'}), self.bar, _class='dropdown') else: self.bar = LI(Anr(T('Log In'), _href='#', _class="dropdown-toggle", data={'toggle': 'dropdown'}), self.bar, _class='dropdown') def bare(): """ In order to do advanced customization we only need the prefix, the user_identifier and the href attribute of items Examples: Use as:: # in module custom_layout.py from gluon import * def navbar(auth_navbar): bar = auth_navbar user = bar["user"] if not user: btn_login = A(current.T("Login"), _href=bar["login"], _class="btn btn-success", _rel="nofollow") btn_register = A(current.T("Sign up"), _href=bar["register"], _class="btn btn-primary", _rel="nofollow") return DIV(btn_register, btn_login, _class="btn-group") else: toggletext = "%s back %s" % (bar["prefix"], user) toggle = A(toggletext, _href="#", _class="dropdown-toggle", _rel="nofollow", **{"_data-toggle": "dropdown"}) li_profile = LI(A(I(_class="icon-user"), ' ', current.T("Account details"), _href=bar["profile"], _rel="nofollow")) li_custom = LI(A(I(_class="icon-book"), ' ', current.T("My Agenda"), _href="#", rel="nofollow")) li_logout = LI(A(I(_class="icon-off"), ' ', current.T("logout"), _href=bar["logout"], _rel="nofollow")) dropdown = UL(li_profile, li_custom, LI('', _class="divider"), li_logout, _class="dropdown-menu", _role="menu") return LI(toggle, dropdown, _class="dropdown") # in models db.py import custom_layout as custom # in layout.html <ul id="navbar" class="nav pull-right"> {{='auth' in globals() and \ custom.navbar(auth.navbar(mode='bare')) or ''}}</ul> """ bare = {} bare['prefix'] = prefix bare['user'] = user_identifier if self.user_id else None for i in items: if i['name'] == T('Log In'): k = 'login' elif i['name'] == T('Sign Up'): k = 'register' elif i['name'] == T('Lost password?'): k = 'request_reset_password' elif i['name'] == T('Forgot username?'): k = 'retrieve_username' elif i['name'] == T('Log Out'): k = 'logout' elif i['name'] == T('Profile'): k = 'profile' elif i['name'] == T('Password'): k = 'change_password' bare[k] = i['href'] self.bar = bare options = {'asmenu': menu, 'dropdown': bootstrap3, 'bare': bare } # Define custom modes. if mode in options and callable(options[mode]): options[mode]() else: s1, s2, s3 = separators if self.user_id: self.bar = SPAN(prefix, user_identifier, s1, Anr(items[0]['name'], _href=items[0]['href']), s3, _class='auth_navbar') else: self.bar = SPAN(s1, Anr(items[0]['name'], _href=items[0]['href']), s3, _class='auth_navbar') for item in items[1:]: self.bar.insert(-1, s2) self.bar.insert(-1, Anr(item['name'], _href=item['href'])) return self.bar def __get_migrate(self, tablename, migrate=True): if type(migrate).__name__ == 'str': return (migrate + tablename + '.table') elif migrate == False: return False else: return True def enable_record_versioning(self, tables, archive_db=None, archive_names='%(tablename)s_archive', current_record='current_record', current_record_label=None): """ Used to enable full record versioning (including auth tables):: auth = Auth(db) auth.define_tables(signature=True) # define our own tables db.define_table('mything',Field('name'),auth.signature) auth.enable_record_versioning(tables=db) tables can be the db (all table) or a list of tables. only tables with modified_by and modified_on fiels (as created by auth.signature) will have versioning. Old record versions will be in table 'mything_archive' automatically defined. when you enable enable_record_versioning, records are never deleted but marked with is_active=False. enable_record_versioning enables a common_filter for every table that filters out records with is_active = False Note: If you use auth.enable_record_versioning, do not use auth.archive or you will end up with duplicates. auth.archive does explicitly what enable_record_versioning does automatically. """ current_record_label = current_record_label or current.T( current_record.replace('_', ' ').title()) for table in tables: fieldnames = table.fields() if ('id' in fieldnames and 'modified_on' in fieldnames and not current_record in fieldnames): table._enable_record_versioning( archive_db=archive_db, archive_name=archive_names, current_record=current_record, current_record_label=current_record_label) def define_signature(self): db = self.db settings = self.settings request = current.request T = current.T reference_user = 'reference %s' % settings.table_user_name def lazy_user(auth=self): return auth.user_id def represent(id, record=None, s=settings): try: user = s.table_user(id) return '%s %s' % (user.get("first_name", user.get("email")), user.get("last_name", '')) except: return id ondelete = self.settings.ondelete self.signature = Table( self.db, 'auth_signature', Field('is_active', 'boolean', default=True, readable=False, writable=False, label=T('Is Active')), Field('created_on', 'datetime', default=request.now, writable=False, readable=False, label=T('Created On')), Field('created_by', reference_user, default=lazy_user, represent=represent, writable=False, readable=False, label=T('Created By'), ondelete=ondelete), Field('modified_on', 'datetime', update=request.now, default=request.now, writable=False, readable=False, label=T('Modified On')), Field('modified_by', reference_user, represent=represent, default=lazy_user, update=lazy_user, writable=False, readable=False, label=T('Modified By'), ondelete=ondelete)) def define_tables(self, username=None, signature=None, migrate=None, fake_migrate=None): """ To be called unless tables are defined manually Examples: Use as:: # defines all needed tables and table files # 'myprefix_auth_user.table', ... auth.define_tables(migrate='myprefix_') # defines all needed tables without migration/table files auth.define_tables(migrate=False) """ db = self.db if migrate is None: migrate = db._migrate if fake_migrate is None: fake_migrate = db._fake_migrate settings = self.settings if username is None: username = settings.use_username else: settings.use_username = username if not self.signature: self.define_signature() if signature == True: signature_list = [self.signature] elif not signature: signature_list = [] elif isinstance(signature, Table): signature_list = [signature] else: signature_list = signature is_not_empty = IS_NOT_EMPTY(error_message=self.messages.is_empty) is_crypted = CRYPT(key=settings.hmac_key, min_length=settings.password_min_length) is_unique_email = [ IS_EMAIL(error_message=self.messages.invalid_email), IS_NOT_IN_DB(db, '%s.email' % settings.table_user_name, error_message=self.messages.email_taken)] if not settings.email_case_sensitive: is_unique_email.insert(1, IS_LOWER()) if not settings.table_user_name in db.tables: passfield = settings.password_field extra_fields = settings.extra_fields.get( settings.table_user_name, []) + signature_list if username or settings.cas_provider: is_unique_username = \ [IS_MATCH('[\w\.\-]+', strict=True, error_message=self.messages.invalid_username), IS_NOT_IN_DB(db, '%s.username' % settings.table_user_name, error_message=self.messages.username_taken)] if not settings.username_case_sensitive: is_unique_username.insert(1, IS_LOWER()) db.define_table( settings.table_user_name, Field('first_name', length=128, default='', label=self.messages.label_first_name, requires=is_not_empty), Field('last_name', length=128, default='', label=self.messages.label_last_name, requires=is_not_empty), Field('email', length=512, default='', label=self.messages.label_email, requires=is_unique_email), Field('username', length=128, default='', label=self.messages.label_username, requires=is_unique_username), Field(passfield, 'password', length=512, readable=False, label=self.messages.label_password, requires=[is_crypted]), Field('registration_key', length=512, writable=False, readable=False, default='', label=self.messages.label_registration_key), Field('reset_password_key', length=512, writable=False, readable=False, default='', label=self.messages.label_reset_password_key), Field('registration_id', length=512, writable=False, readable=False, default='', label=self.messages.label_registration_id), *extra_fields, **dict( migrate=self.__get_migrate(settings.table_user_name, migrate), fake_migrate=fake_migrate, format='%(username)s')) else: db.define_table( settings.table_user_name, Field('first_name', length=128, default='', label=self.messages.label_first_name, requires=is_not_empty), Field('last_name', length=128, default='', label=self.messages.label_last_name, requires=is_not_empty), Field('email', length=512, default='', label=self.messages.label_email, requires=is_unique_email), Field(passfield, 'password', length=512, readable=False, label=self.messages.label_password, requires=[is_crypted]), Field('registration_key', length=512, writable=False, readable=False, default='', label=self.messages.label_registration_key), Field('reset_password_key', length=512, writable=False, readable=False, default='', label=self.messages.label_reset_password_key), Field('registration_id', length=512, writable=False, readable=False, default='', label=self.messages.label_registration_id), *extra_fields, **dict( migrate=self.__get_migrate(settings.table_user_name, migrate), fake_migrate=fake_migrate, format='%(first_name)s %(last_name)s (%(id)s)')) reference_table_user = 'reference %s' % settings.table_user_name if not settings.table_group_name in db.tables: extra_fields = settings.extra_fields.get( settings.table_group_name, []) + signature_list db.define_table( settings.table_group_name, Field('role', length=512, default='', label=self.messages.label_role, requires=IS_NOT_IN_DB(db, '%s.role' % settings.table_group_name)), Field('description', 'text', label=self.messages.label_description), *extra_fields, **dict( migrate=self.__get_migrate( settings.table_group_name, migrate), fake_migrate=fake_migrate, format='%(role)s (%(id)s)')) reference_table_group = 'reference %s' % settings.table_group_name if not settings.table_membership_name in db.tables: extra_fields = settings.extra_fields.get( settings.table_membership_name, []) + signature_list db.define_table( settings.table_membership_name, Field('user_id', reference_table_user, label=self.messages.label_user_id), Field('group_id', reference_table_group, label=self.messages.label_group_id), *extra_fields, **dict( migrate=self.__get_migrate( settings.table_membership_name, migrate), fake_migrate=fake_migrate)) if not settings.table_permission_name in db.tables: extra_fields = settings.extra_fields.get( settings.table_permission_name, []) + signature_list db.define_table( settings.table_permission_name, Field('group_id', reference_table_group, label=self.messages.label_group_id), Field('name', default='default', length=512, label=self.messages.label_name, requires=is_not_empty), Field('table_name', length=512, label=self.messages.label_table_name), Field('record_id', 'integer', default=0, label=self.messages.label_record_id, requires=IS_INT_IN_RANGE(0, 10 ** 9)), *extra_fields, **dict( migrate=self.__get_migrate( settings.table_permission_name, migrate), fake_migrate=fake_migrate)) if not settings.table_event_name in db.tables: db.define_table( settings.table_event_name, Field('time_stamp', 'datetime', default=current.request.now, label=self.messages.label_time_stamp), Field('client_ip', default=current.request.client, label=self.messages.label_client_ip), Field('user_id', reference_table_user, default=None, label=self.messages.label_user_id), Field('origin', default='auth', length=512, label=self.messages.label_origin, requires=is_not_empty), Field('description', 'text', default='', label=self.messages.label_description, requires=is_not_empty), *settings.extra_fields.get(settings.table_event_name, []), **dict( migrate=self.__get_migrate( settings.table_event_name, migrate), fake_migrate=fake_migrate)) now = current.request.now if settings.cas_domains: if not settings.table_cas_name in db.tables: db.define_table( settings.table_cas_name, Field('user_id', reference_table_user, default=None, label=self.messages.label_user_id), Field('created_on', 'datetime', default=now), Field('service', requires=IS_URL()), Field('ticket'), Field('renew', 'boolean', default=False), *settings.extra_fields.get(settings.table_cas_name, []), **dict( migrate=self.__get_migrate( settings.table_cas_name, migrate), fake_migrate=fake_migrate)) if not db._lazy_tables: settings.table_user = db[settings.table_user_name] settings.table_group = db[settings.table_group_name] settings.table_membership = db[settings.table_membership_name] settings.table_permission = db[settings.table_permission_name] settings.table_event = db[settings.table_event_name] if settings.cas_domains: settings.table_cas = db[settings.table_cas_name] if settings.cas_provider: # THIS IS NOT LAZY settings.actions_disabled = \ ['profile', 'register', 'change_password', 'request_reset_password', 'retrieve_username'] from gluon.contrib.login_methods.cas_auth import CasAuth maps = settings.cas_maps if not maps: table_user = self.table_user() maps = dict((name, lambda v, n=name: v.get(n, None)) for name in table_user.fields if name != 'id' and table_user[name].readable) maps['registration_id'] = \ lambda v, p=settings.cas_provider: '%s/%s' % (p, v['user']) actions = [settings.cas_actions['login'], settings.cas_actions['servicevalidate'], settings.cas_actions['logout']] settings.login_form = CasAuth( casversion=2, urlbase=settings.cas_provider, actions=actions, maps=maps) return self def log_event(self, description, vars=None, origin='auth'): """ Examples: Use as:: auth.log_event(description='this happened', origin='auth') """ if not self.settings.logging_enabled or not description: return elif self.is_logged_in(): user_id = self.user.id else: user_id = None # user unknown vars = vars or {} # log messages should not be translated if type(description).__name__ == 'lazyT': description = description.m self.table_event().insert( description=str(description % vars), origin=origin, user_id=user_id) def get_or_create_user(self, keys, update_fields=['email'], login=True, get=True): """ Used for alternate login methods: If the user exists already then password is updated. If the user doesn't yet exist, then they are created. """ table_user = self.table_user() user = None checks = [] # make a guess about who this user is for fieldname in ['registration_id', 'username', 'email']: if fieldname in table_user.fields() and \ keys.get(fieldname, None): checks.append(fieldname) value = keys[fieldname] user = table_user(**{fieldname: value}) if user: break if not checks: return None if not 'registration_id' in keys: keys['registration_id'] = keys[checks[0]] # if we think we found the user but registration_id does not match, # make new user if 'registration_id' in checks \ and user \ and user.registration_id \ and ('registration_id' not in keys or user.registration_id != str(keys['registration_id'])): user = None # THINK MORE ABOUT THIS? DO WE TRUST OPENID PROVIDER? if user: if not get: # added for register_bare to avoid overwriting users return None update_keys = dict(registration_id=keys['registration_id']) for key in update_fields: if key in keys: update_keys[key] = keys[key] user.update_record(**update_keys) elif checks: if not 'first_name' in keys and 'first_name' in table_user.fields: guess = keys.get('email', 'anonymous').split('@')[0] keys['first_name'] = keys.get('username', guess) user_id = table_user.insert(**table_user._filter_fields(keys)) user = table_user[user_id] if self.settings.create_user_groups: group_id = self.add_group( self.settings.create_user_groups % user) self.add_membership(group_id, user_id) if self.settings.everybody_group_id: self.add_membership(self.settings.everybody_group_id, user_id) if login: self.user = user return user def basic(self, basic_auth_realm=False): """ Performs basic login. Args: basic_auth_realm: optional basic http authentication realm. Can take str or unicode or function or callable or boolean. reads current.request.env.http_authorization and returns basic_allowed,basic_accepted,user. if basic_auth_realm is defined is a callable it's return value is used to set the basic authentication realm, if it's a string its content is used instead. Otherwise basic authentication realm is set to the application name. If basic_auth_realm is None or False (the default) the behavior is to skip sending any challenge. """ if not self.settings.allow_basic_login: return (False, False, False) basic = current.request.env.http_authorization if basic_auth_realm: if callable(basic_auth_realm): basic_auth_realm = basic_auth_realm() elif isinstance(basic_auth_realm, (unicode, str)): basic_realm = unicode(basic_auth_realm) elif basic_auth_realm is True: basic_realm = u'' + current.request.application http_401 = HTTP(401, u'Not Authorized', **{'WWW-Authenticate': u'Basic realm="' + basic_realm + '"'}) if not basic or not basic[:6].lower() == 'basic ': if basic_auth_realm: raise http_401 return (True, False, False) (username, sep, password) = base64.b64decode(basic[6:]).partition(':') is_valid_user = sep and self.login_bare(username, password) if not is_valid_user and basic_auth_realm: raise http_401 return (True, True, is_valid_user) def login_user(self, user): """ Logins the `user = db.auth_user(id)` """ from gluon.settings import global_settings if global_settings.web2py_runtime_gae: user = Row(self.table_user()._filter_fields(user, id=True)) delattr(user, 'password') else: user = Row(user) for key, value in user.items(): if callable(value) or key == 'password': delattr(user, key) if self.settings.renew_session_onlogin: current.session.renew(clear_session=not self.settings.keep_session_onlogin) current.session.auth = Storage(user=user, last_visit=current.request.now, expiration=self.settings.expiration, hmac_key=web2py_uuid()) self.user = user self.update_groups() def _get_login_settings(self): table_user = self.table_user() userfield = self.settings.login_userfield or 'username' \ if 'username' in table_user.fields else 'email' passfield = self.settings.password_field return Storage({"table_user": table_user, "userfield": userfield, "passfield": passfield}) def login_bare(self, username, password): """ Logins user as specified by username (or email) and password """ settings = self._get_login_settings() user = settings.table_user(**{settings.userfield: \ username}) if user and user.get(settings.passfield, False): password = settings.table_user[ settings.passfield].validate(password)[0] if ((user.registration_key is None or not user.registration_key.strip()) and password == user[settings.passfield]): self.login_user(user) return user else: # user not in database try other login methods for login_method in self.settings.login_methods: if login_method != self and login_method(username, password): self.user = username return username return False def register_bare(self, **fields): """ Registers a user as specified by username (or email) and a raw password. """ settings = self._get_login_settings() if not fields.get(settings.passfield): raise ValueError("register_bare: " + "password not provided or invalid") elif not fields.get(settings.userfield): raise ValueError("register_bare: " + "userfield not provided or invalid") fields[settings.passfield] = settings.table_user[settings.passfield].validate(fields[settings.passfield])[0] user = self.get_or_create_user(fields, login=False, get=False, update_fields=self.settings.update_fields) if not user: # get or create did not create a user (it ignores duplicate records) return False return user def cas_login(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, version=2, ): request = current.request response = current.response session = current.session db, table = self.db, self.table_cas() session._cas_service = request.vars.service or session._cas_service if not request.env.http_host in self.settings.cas_domains or \ not session._cas_service: raise HTTP(403, 'not authorized') def allow_access(interactivelogin=False): row = table(service=session._cas_service, user_id=self.user.id) if row: ticket = row.ticket else: ticket = 'ST-' + web2py_uuid() table.insert(service=session._cas_service, user_id=self.user.id, ticket=ticket, created_on=request.now, renew=interactivelogin) service = session._cas_service query_sep = '&' if '?' in service else '?' del session._cas_service if 'warn' in request.vars and not interactivelogin: response.headers[ 'refresh'] = "5;URL=%s" % service + query_sep + "ticket=" + ticket return A("Continue to %s" % service, _href=service + query_sep + "ticket=" + ticket) else: redirect(service + query_sep + "ticket=" + ticket) if self.is_logged_in() and not 'renew' in request.vars: return allow_access() elif not self.is_logged_in() and 'gateway' in request.vars: redirect(service) def cas_onaccept(form, onaccept=onaccept): if not onaccept is DEFAULT: onaccept(form) return allow_access(interactivelogin=True) return self.login(next, onvalidation, cas_onaccept, log) def cas_validate(self, version=2, proxy=False): request = current.request db, table = self.db, self.table_cas() current.response.headers['Content-Type'] = 'text' ticket = request.vars.ticket renew = 'renew' in request.vars row = table(ticket=ticket) success = False if row: userfield = self.settings.login_userfield or 'username' \ if 'username' in table.fields else 'email' # If ticket is a service Ticket and RENEW flag respected if ticket[0:3] == 'ST-' and \ not ((row.renew and renew) ^ renew): user = self.table_user()(row.user_id) row.delete_record() success = True def build_response(body): return '<?xml version="1.0" encoding="UTF-8"?>\n' +\ TAG['cas:serviceResponse']( body, **{'_xmlns:cas': 'http://www.yale.edu/tp/cas'}).xml() if success: if version == 1: message = 'yes\n%s' % user[userfield] else: # assume version 2 username = user.get('username', user[userfield]) message = build_response( TAG['cas:authenticationSuccess']( TAG['cas:user'](username), *[TAG['cas:' + field.name](user[field.name]) for field in self.table_user() if field.readable])) else: if version == 1: message = 'no\n' elif row: message = build_response(TAG['cas:authenticationFailure']()) else: message = build_response( TAG['cas:authenticationFailure']( 'Ticket %s not recognized' % ticket, _code='INVALID TICKET')) raise HTTP(200, message) def _reset_two_factor_auth(self, session): """When two-step authentication is enabled, this function is used to clear the session after successfully completing second challenge or when the maximum number of tries allowed has expired. """ session.auth_two_factor_user = None session.auth_two_factor = None session.auth_two_factor_enabled = False # Allow up to 4 attempts (the 1st one plus 3 more) session.auth_two_factor_tries_left = 3 def login(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a login form """ table_user = self.table_user() settings = self.settings if 'username' in table_user.fields or \ not settings.login_email_validate: tmpvalidator = IS_NOT_EMPTY(error_message=self.messages.is_empty) if not settings.username_case_sensitive: tmpvalidator = [IS_LOWER(), tmpvalidator] else: tmpvalidator = IS_EMAIL(error_message=self.messages.invalid_email) if not settings.email_case_sensitive: tmpvalidator = [IS_LOWER(), tmpvalidator] request = current.request response = current.response session = current.session passfield = settings.password_field try: table_user[passfield].requires[-1].min_length = 0 except: pass ### use session for federated login snext = self.get_vars_next() if snext and self.settings.prevent_open_redirect_attacks: items = snext.split('/') if '//' in snext and items[2] != request.env.http_host: snext = None if snext: session._auth_next = snext elif session._auth_next: snext = session._auth_next ### pass if next is DEFAULT: # important for security next = settings.login_next if callable(next): next = next() user_next = snext if user_next: external = user_next.split('://') if external[0].lower() in ['http', 'https', 'ftp']: host_next = user_next.split('//', 1)[-1].split('/')[0] if host_next in settings.cas_domains: next = user_next else: next = user_next if onvalidation is DEFAULT: onvalidation = settings.login_onvalidation if onaccept is DEFAULT: onaccept = settings.login_onaccept if log is DEFAULT: log = self.messages['login_log'] onfail = settings.login_onfail user = None # default #Setup the default field used for the form multi_login = False if self.settings.login_userfield: username = self.settings.login_userfield else: if 'username' in table_user.fields: username = 'username' else: username = 'email' if self.settings.multi_login: multi_login = True old_requires = table_user[username].requires table_user[username].requires = tmpvalidator # If two-factor authentication is enabled, and the maximum # number of tries allowed is used up, reset the session to # pre-login state with two-factor auth if session.auth_two_factor_enabled and session.auth_two_factor_tries_left < 1: # Exceeded maximum allowed tries for this code. Require user to enter # username and password again. user = None accepted_form = False self._reset_two_factor_auth(session) # Redirect to the default 'next' page without logging # in. If that page requires login, user will be redirected # back to the main login form redirect(next, client_side=settings.client_side) # Before showing the default login form, check whether # we are already on the second step of two-step authentication. # If we are, then skip this login form and use the form for the # second challenge instead. # Note to devs: The code inside the if-block is unchanged from the # previous version of this file, other than for indentation inside # to put it inside the if-block if session.auth_two_factor_user is None: if settings.remember_me_form: extra_fields = [ Field('remember_me', 'boolean', default=False, label = self.messages.label_remember_me)] else: extra_fields = [] # do we use our own login form, or from a central source? if settings.login_form == self: form = SQLFORM( table_user, fields=[username, passfield], hidden=dict(_next=next), showid=settings.showid, submit_button=self.messages.login_button, delete_label=self.messages.delete_label, formstyle=settings.formstyle, separator=settings.label_separator, extra_fields = extra_fields, ) captcha = settings.login_captcha or \ (settings.login_captcha != False and settings.captcha) if captcha: addrow(form, captcha.label, captcha, captcha.comment, settings.formstyle, 'captcha__row') accepted_form = False if form.accepts(request, session if self.csrf_prevention else None, formname='login', dbio=False, onvalidation=onvalidation, hideerror=settings.hideerror): accepted_form = True # check for username in db entered_username = form.vars[username] if multi_login and '@' in entered_username: # if '@' in username check for email, not username user = table_user(email = entered_username) else: user = table_user(**{username: entered_username}) if user: # user in db, check if registration pending or disabled temp_user = user if temp_user.registration_key == 'pending': response.flash = self.messages.registration_pending return form elif temp_user.registration_key in ('disabled', 'blocked'): response.flash = self.messages.login_disabled return form elif (not temp_user.registration_key is None and temp_user.registration_key.strip()): response.flash = \ self.messages.registration_verifying return form # try alternate logins 1st as these have the # current version of the password user = None for login_method in settings.login_methods: if login_method != self and \ login_method(request.vars[username], request.vars[passfield]): if not self in settings.login_methods: # do not store password in db form.vars[passfield] = None user = self.get_or_create_user( form.vars, settings.update_fields) break if not user: # alternates have failed, maybe because service inaccessible if settings.login_methods[0] == self: # try logging in locally using cached credentials if form.vars.get(passfield, '') == temp_user[passfield]: # success user = temp_user else: # user not in db if not settings.alternate_requires_registration: # we're allowed to auto-register users from external systems for login_method in settings.login_methods: if login_method != self and \ login_method(request.vars[username], request.vars[passfield]): if not self in settings.login_methods: # do not store password in db form.vars[passfield] = None user = self.get_or_create_user( form.vars, settings.update_fields) break if not user: self.log_event(self.messages['login_failed_log'], request.post_vars) # invalid login session.flash = self.messages.invalid_login callback(onfail, None) redirect( self.url(args=request.args, vars=request.get_vars), client_side=settings.client_side) else: # use a central authentication server cas = settings.login_form cas_user = cas.get_user() if cas_user: cas_user[passfield] = None user = self.get_or_create_user( table_user._filter_fields(cas_user), settings.update_fields) elif hasattr(cas, 'login_form'): return cas.login_form() else: # we need to pass through login again before going on next = self.url(settings.function, args='login') redirect(cas.login_url(next), client_side=settings.client_side) # Extra login logic for two-factor authentication ################################################# # If the 'user' variable has a value, this means that the first # authentication step was successful (i.e. user provided correct # username and password at the first challenge). # Check if this user is signed up for two-factor authentication # Default rule is that the user must be part of a group that is called # auth.settings.two_factor_authentication_group if user and self.settings.two_factor_authentication_group: role = self.settings.two_factor_authentication_group session.auth_two_factor_enabled = self.has_membership(user_id=user.id, role=role) # challenge if session.auth_two_factor_enabled: form = SQLFORM.factory( Field('authentication_code', required=True, comment='This code was emailed to you and is required for login.'), hidden=dict(_next=next), formstyle=settings.formstyle, separator=settings.label_separator ) # accepted_form is used by some default web2py code later in the # function that handles running specified functions before redirect # Set it to False until the challenge form is accepted. accepted_form = False # Handle the case when a user has submitted the login/password # form successfully, and the password has been validated, but # the two-factor form has not been displayed or validated yet. if session.auth_two_factor_user is None and user is not None: session.auth_two_factor_user = user # store the validated user and associate with this session session.auth_two_factor = random.randint(100000, 999999) session.auth_two_factor_tries_left = 3 # Allow user to try up to 4 times # TODO: Add some error checking to handle cases where email cannot be sent self.settings.mailer.send( to=user.email, subject="Two-step Login Authentication Code", message="Your temporary login code is {0}".format(session.auth_two_factor)) if form.accepts(request, session if self.csrf_prevention else None, formname='login', dbio=False, onvalidation=onvalidation, hideerror=settings.hideerror): accepted_form = True if form.vars['authentication_code'] == str(session.auth_two_factor): # Handle the case when the two-factor form has been successfully validated # and the user was previously stored (the current user should be None because # in this case, the previous username/password login form should not be displayed. # This will allow the code after the 2-factor authentication block to proceed as # normal. if user is None or user == session.auth_two_factor_user: user = session.auth_two_factor_user # For security, because the username stored in the # session somehow does not match the just validated # user. Should not be possible without session stealing # which is hard with SSL. elif user != session.auth_two_factor_user: user = None # Either way, the user and code associated with this session should # be removed. This handles cases where the session login may have # expired but browser window is open, so the old session key and # session usernamem will still exist self._reset_two_factor_auth(session) else: # TODO: Limit the number of retries allowed. response.flash = 'Incorrect code. {0} more attempt(s) remaining.'.format(session.auth_two_factor_tries_left) session.auth_two_factor_tries_left -= 1 return form else: return form # End login logic for two-factor authentication # process authenticated users if user: user = Row(table_user._filter_fields(user, id=True)) # process authenticated users # user wants to be logged in for longer self.login_user(user) session.auth.expiration = \ request.post_vars.remember_me and \ settings.long_expiration or \ settings.expiration session.auth.remember_me = 'remember_me' in request.post_vars self.log_event(log, user) session.flash = self.messages.logged_in # how to continue if settings.login_form == self: if accepted_form: callback(onaccept, form) if next == session._auth_next: session._auth_next = None next = replace_id(next, form) redirect(next, client_side=settings.client_side) table_user[username].requires = old_requires return form elif user: callback(onaccept, None) if next == session._auth_next: del session._auth_next redirect(next, client_side=settings.client_side) def logout(self, next=DEFAULT, onlogout=DEFAULT, log=DEFAULT): """ Logouts and redirects to login """ # Clear out 2-step authentication information if user logs # out. This information is also cleared on successful login. self._reset_two_factor_auth(current.session) if next is DEFAULT: next = self.get_vars_next() or self.settings.logout_next if onlogout is DEFAULT: onlogout = self.settings.logout_onlogout if onlogout: onlogout(self.user) if log is DEFAULT: log = self.messages['logout_log'] if self.user: self.log_event(log, self.user) if self.settings.login_form != self: cas = self.settings.login_form cas_user = cas.get_user() if cas_user: next = cas.logout_url(next) current.session.auth = None if self.settings.renew_session_onlogout: current.session.renew(clear_session=not self.settings.keep_session_onlogout) current.session.flash = self.messages.logged_out if not next is None: redirect(next) def register(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a registration form """ table_user = self.table_user() request = current.request response = current.response session = current.session if self.is_logged_in(): redirect(self.settings.logged_url, client_side=self.settings.client_side) if next is DEFAULT: next = self.get_vars_next() or self.settings.register_next if onvalidation is DEFAULT: onvalidation = self.settings.register_onvalidation if onaccept is DEFAULT: onaccept = self.settings.register_onaccept if log is DEFAULT: log = self.messages['register_log'] table_user = self.table_user() if self.settings.login_userfield: username = self.settings.login_userfield elif 'username' in table_user.fields: username = 'username' else: username = 'email' # Ensure the username field is unique. unique_validator = IS_NOT_IN_DB(self.db, table_user[username]) if not table_user[username].requires: table_user[username].requires = unique_validator elif isinstance(table_user[username].requires, (list, tuple)): if not any([isinstance(validator, IS_NOT_IN_DB) for validator in table_user[username].requires]): if isinstance(table_user[username].requires, list): table_user[username].requires.append(unique_validator) else: table_user[username].requires += (unique_validator, ) elif not isinstance(table_user[username].requires, IS_NOT_IN_DB): table_user[username].requires = [table_user[username].requires, unique_validator] passfield = self.settings.password_field formstyle = self.settings.formstyle if self.settings.register_verify_password: extra_fields = [ Field("password_two", "password", requires=IS_EQUAL_TO( request.post_vars.get(passfield, None), error_message=self.messages.mismatched_password), label=current.T("Confirm Password"))] else: extra_fields = [] form = SQLFORM(table_user, fields=self.settings.register_fields, hidden=dict(_next=next), showid=self.settings.showid, submit_button=self.messages.register_button, delete_label=self.messages.delete_label, formstyle=formstyle, separator=self.settings.label_separator, extra_fields = extra_fields ) captcha = self.settings.register_captcha or self.settings.captcha if captcha: addrow(form, captcha.label, captcha, captcha.comment, self.settings.formstyle, 'captcha__row') #Add a message if specified if self.settings.pre_registration_div: addrow(form, '', DIV(_id="pre-reg", *self.settings.pre_registration_div), '', formstyle, '') table_user.registration_key.default = key = web2py_uuid() if form.accepts(request, session if self.csrf_prevention else None, formname='register', onvalidation=onvalidation, hideerror=self.settings.hideerror): description = self.messages.group_description % form.vars if self.settings.create_user_groups: group_id = self.add_group( self.settings.create_user_groups % form.vars, description) self.add_membership(group_id, form.vars.id) if self.settings.everybody_group_id: self.add_membership( self.settings.everybody_group_id, form.vars.id) if self.settings.registration_requires_verification: link = self.url( self.settings.function, args=('verify_email', key), scheme=True) d = dict(form.vars) d.update(dict(key=key, link=link, username=form.vars[username])) if not (self.settings.mailer and self.settings.mailer.send( to=form.vars.email, subject=self.messages.verify_email_subject, message=self.messages.verify_email % d)): self.db.rollback() response.flash = self.messages.unable_send_email return form session.flash = self.messages.email_sent if self.settings.registration_requires_approval and \ not self.settings.registration_requires_verification: table_user[form.vars.id] = dict(registration_key='pending') session.flash = self.messages.registration_pending elif (not self.settings.registration_requires_verification or self.settings.login_after_registration): if not self.settings.registration_requires_verification: table_user[form.vars.id] = dict(registration_key='') session.flash = self.messages.registration_successful user = table_user(**{username: form.vars[username]}) self.login_user(user) session.flash = self.messages.logged_in self.log_event(log, form.vars) callback(onaccept, form) if not next: next = self.url(args=request.args) else: next = replace_id(next, form) redirect(next, client_side=self.settings.client_side) return form def is_logged_in(self): """ Checks if the user is logged in and returns True/False. If so user is in auth.user as well as in session.auth.user """ if self.user: return True return False def verify_email(self, next=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Action used to verify the registration email """ key = getarg(-1) table_user = self.table_user() user = table_user(registration_key=key) if not user: redirect(self.settings.login_url) if self.settings.registration_requires_approval: user.update_record(registration_key='pending') current.session.flash = self.messages.registration_pending else: user.update_record(registration_key='') current.session.flash = self.messages.email_verified # make sure session has same user.registrato_key as db record if current.session.auth and current.session.auth.user: current.session.auth.user.registration_key = user.registration_key if log is DEFAULT: log = self.messages['verify_email_log'] if next is DEFAULT: next = self.settings.verify_email_next if onaccept is DEFAULT: onaccept = self.settings.verify_email_onaccept self.log_event(log, user) callback(onaccept, user) redirect(next) def retrieve_username(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a form to retrieve the user username (only if there is a username field) """ table_user = self.table_user() if not 'username' in table_user.fields: raise HTTP(404) request = current.request response = current.response session = current.session captcha = self.settings.retrieve_username_captcha or \ (self.settings.retrieve_username_captcha != False and self.settings.captcha) if not self.settings.mailer: response.flash = self.messages.function_disabled return '' if next is DEFAULT: next = self.get_vars_next() or self.settings.retrieve_username_next if onvalidation is DEFAULT: onvalidation = self.settings.retrieve_username_onvalidation if onaccept is DEFAULT: onaccept = self.settings.retrieve_username_onaccept if log is DEFAULT: log = self.messages['retrieve_username_log'] old_requires = table_user.email.requires table_user.email.requires = [IS_IN_DB(self.db, table_user.email, error_message=self.messages.invalid_email)] form = SQLFORM(table_user, fields=['email'], hidden=dict(_next=next), showid=self.settings.showid, submit_button=self.messages.submit_button, delete_label=self.messages.delete_label, formstyle=self.settings.formstyle, separator=self.settings.label_separator ) if captcha: addrow(form, captcha.label, captcha, captcha.comment, self.settings.formstyle, 'captcha__row') if form.accepts(request, session if self.csrf_prevention else None, formname='retrieve_username', dbio=False, onvalidation=onvalidation, hideerror=self.settings.hideerror): users = table_user._db(table_user.email==form.vars.email).select() if not users: current.session.flash = \ self.messages.invalid_email redirect(self.url(args=request.args)) username = ', '.join(u.username for u in users) self.settings.mailer.send(to=form.vars.email, subject=self.messages.retrieve_username_subject, message=self.messages.retrieve_username % dict(username=username)) session.flash = self.messages.email_sent for user in users: self.log_event(log, user) callback(onaccept, form) if not next: next = self.url(args=request.args) else: next = replace_id(next, form) redirect(next) table_user.email.requires = old_requires return form def random_password(self): import string import random password = '' specials = r'!#$*' for i in range(0, 3): password += random.choice(string.lowercase) password += random.choice(string.uppercase) password += random.choice(string.digits) password += random.choice(specials) return ''.join(random.sample(password, len(password))) def reset_password_deprecated(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a form to reset the user password (deprecated) """ table_user = self.table_user() request = current.request response = current.response session = current.session if not self.settings.mailer: response.flash = self.messages.function_disabled return '' if next is DEFAULT: next = self.get_vars_next() or self.settings.retrieve_password_next if onvalidation is DEFAULT: onvalidation = self.settings.retrieve_password_onvalidation if onaccept is DEFAULT: onaccept = self.settings.retrieve_password_onaccept if log is DEFAULT: log = self.messages['retrieve_password_log'] old_requires = table_user.email.requires table_user.email.requires = [IS_IN_DB(self.db, table_user.email, error_message=self.messages.invalid_email)] form = SQLFORM(table_user, fields=['email'], hidden=dict(_next=next), showid=self.settings.showid, submit_button=self.messages.submit_button, delete_label=self.messages.delete_label, formstyle=self.settings.formstyle, separator=self.settings.label_separator ) if form.accepts(request, session if self.csrf_prevention else None, formname='retrieve_password', dbio=False, onvalidation=onvalidation, hideerror=self.settings.hideerror): user = table_user(email=form.vars.email) if not user: current.session.flash = \ self.messages.invalid_email redirect(self.url(args=request.args)) elif user.registration_key in ('pending', 'disabled', 'blocked'): current.session.flash = \ self.messages.registration_pending redirect(self.url(args=request.args)) password = self.random_password() passfield = self.settings.password_field d = { passfield: str(table_user[passfield].validate(password)[0]), 'registration_key': '' } user.update_record(**d) if self.settings.mailer and \ self.settings.mailer.send(to=form.vars.email, subject=self.messages.retrieve_password_subject, message=self.messages.retrieve_password % dict(password=password)): session.flash = self.messages.email_sent else: session.flash = self.messages.unable_to_send_email self.log_event(log, user) callback(onaccept, form) if not next: next = self.url(args=request.args) else: next = replace_id(next, form) redirect(next) table_user.email.requires = old_requires return form def reset_password(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a form to reset the user password """ table_user = self.table_user() request = current.request # response = current.response session = current.session if next is DEFAULT: next = self.get_vars_next() or self.settings.reset_password_next if self.settings.prevent_password_reset_attacks: key = request.vars.key if key: session._reset_password_key = key redirect(self.url(args='reset_password')) else: key = session._reset_password_key else: key = request.vars.key try: t0 = int(key.split('-')[0]) if time.time() - t0 > 60 * 60 * 24: raise Exception user = table_user(reset_password_key=key) if not user: raise Exception except Exception: session.flash = self.messages.invalid_reset_password redirect(next, client_side=self.settings.client_side) passfield = self.settings.password_field form = SQLFORM.factory( Field('new_password', 'password', label=self.messages.new_password, requires=self.table_user()[passfield].requires), Field('new_password2', 'password', label=self.messages.verify_password, requires=[IS_EXPR( 'value==%s' % repr(request.vars.new_password), self.messages.mismatched_password)]), submit_button=self.messages.password_reset_button, hidden=dict(_next=next), formstyle=self.settings.formstyle, separator=self.settings.label_separator ) if form.accepts(request, session, hideerror=self.settings.hideerror): user.update_record( **{passfield: str(form.vars.new_password), 'registration_key': '', 'reset_password_key': ''}) session.flash = self.messages.password_changed if self.settings.login_after_password_change: self.login_user(user) redirect(next, client_side=self.settings.client_side) return form def request_reset_password(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a form to reset the user password """ table_user = self.table_user() request = current.request response = current.response session = current.session captcha = self.settings.retrieve_password_captcha or \ (self.settings.retrieve_password_captcha != False and self.settings.captcha) if next is DEFAULT: next = self.get_vars_next() or self.settings.request_reset_password_next if not self.settings.mailer: response.flash = self.messages.function_disabled return '' if onvalidation is DEFAULT: onvalidation = self.settings.reset_password_onvalidation if onaccept is DEFAULT: onaccept = self.settings.reset_password_onaccept if log is DEFAULT: log = self.messages['reset_password_log'] userfield = self.settings.login_userfield or 'username' \ if 'username' in table_user.fields else 'email' if userfield == 'email': table_user.email.requires = [ IS_EMAIL(error_message=self.messages.invalid_email), IS_IN_DB(self.db, table_user.email, error_message=self.messages.invalid_email)] if not self.settings.email_case_sensitive: table_user.email.requires.insert(0, IS_LOWER()) else: table_user.username.requires = [ IS_IN_DB(self.db, table_user.username, error_message=self.messages.invalid_username)] if not self.settings.username_case_sensitive: table_user.username.requires.insert(0, IS_LOWER()) form = SQLFORM(table_user, fields=[userfield], hidden=dict(_next=next), showid=self.settings.showid, submit_button=self.messages.password_reset_button, delete_label=self.messages.delete_label, formstyle=self.settings.formstyle, separator=self.settings.label_separator ) if captcha: addrow(form, captcha.label, captcha, captcha.comment, self.settings.formstyle, 'captcha__row') if form.accepts(request, session if self.csrf_prevention else None, formname='reset_password', dbio=False, onvalidation=onvalidation, hideerror=self.settings.hideerror): user = table_user(**{userfield:form.vars.get(userfield)}) if not user: session.flash = self.messages['invalid_%s' % userfield] redirect(self.url(args=request.args), client_side=self.settings.client_side) elif user.registration_key in ('pending', 'disabled', 'blocked'): session.flash = self.messages.registration_pending redirect(self.url(args=request.args), client_side=self.settings.client_side) if self.email_reset_password(user): session.flash = self.messages.email_sent else: session.flash = self.messages.unable_to_send_email self.log_event(log, user) callback(onaccept, form) if not next: next = self.url(args=request.args) else: next = replace_id(next, form) redirect(next, client_side=self.settings.client_side) # old_requires = table_user.email.requires return form def email_reset_password(self, user): reset_password_key = str(int(time.time())) + '-' + web2py_uuid() link = self.url(self.settings.function, args=('reset_password',), vars={'key': reset_password_key}, scheme=True) d = dict(user) d.update(dict(key=reset_password_key, link=link)) if self.settings.mailer and self.settings.mailer.send( to=user.email, subject=self.messages.reset_password_subject, message=self.messages.reset_password % d): user.update_record(reset_password_key=reset_password_key) return True return False def retrieve_password(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): if self.settings.reset_password_requires_verification: return self.request_reset_password(next, onvalidation, onaccept, log) else: return self.reset_password_deprecated(next, onvalidation, onaccept, log) def change_password(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a form that lets the user change password """ if not self.is_logged_in(): redirect(self.settings.login_url, client_side=self.settings.client_side) db = self.db table_user = self.table_user() s = db(table_user.id == self.user.id) request = current.request session = current.session if next is DEFAULT: next = self.get_vars_next() or self.settings.change_password_next if onvalidation is DEFAULT: onvalidation = self.settings.change_password_onvalidation if onaccept is DEFAULT: onaccept = self.settings.change_password_onaccept if log is DEFAULT: log = self.messages['change_password_log'] passfield = self.settings.password_field requires = table_user[passfield].requires if not isinstance(requires, (list, tuple)): requires = [requires] requires = filter(lambda t: isinstance(t, CRYPT), requires) if requires: requires[0].min_length = 0 form = SQLFORM.factory( Field('old_password', 'password', requires=requires, label=self.messages.old_password), Field('new_password', 'password', label=self.messages.new_password, requires=table_user[passfield].requires), Field('new_password2', 'password', label=self.messages.verify_password, requires=[IS_EXPR( 'value==%s' % repr(request.vars.new_password), self.messages.mismatched_password)]), submit_button=self.messages.password_change_button, hidden=dict(_next=next), formstyle=self.settings.formstyle, separator=self.settings.label_separator ) if form.accepts(request, session, formname='change_password', onvalidation=onvalidation, hideerror=self.settings.hideerror): current_user = s.select(limitby=(0, 1), orderby_on_limitby=False).first() if not form.vars['old_password'] == current_user[passfield]: form.errors['old_password'] = self.messages.invalid_password else: d = {passfield: str(form.vars.new_password)} s.update(**d) session.flash = self.messages.password_changed self.log_event(log, self.user) callback(onaccept, form) if not next: next = self.url(args=request.args) else: next = replace_id(next, form) redirect(next, client_side=self.settings.client_side) return form def profile(self, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, ): """ Returns a form that lets the user change his/her profile """ table_user = self.table_user() if not self.is_logged_in(): redirect(self.settings.login_url, client_side=self.settings.client_side) passfield = self.settings.password_field table_user[passfield].writable = False request = current.request session = current.session if next is DEFAULT: next = self.get_vars_next() or self.settings.profile_next if onvalidation is DEFAULT: onvalidation = self.settings.profile_onvalidation if onaccept is DEFAULT: onaccept = self.settings.profile_onaccept if log is DEFAULT: log = self.messages['profile_log'] form = SQLFORM( table_user, self.user.id, fields=self.settings.profile_fields, hidden=dict(_next=next), showid=self.settings.showid, submit_button=self.messages.profile_save_button, delete_label=self.messages.delete_label, upload=self.settings.download_url, formstyle=self.settings.formstyle, separator=self.settings.label_separator, deletable=self.settings.allow_delete_accounts, ) if form.accepts(request, session, formname='profile', onvalidation=onvalidation, hideerror=self.settings.hideerror): self.user.update(table_user._filter_fields(form.vars)) session.flash = self.messages.profile_updated self.log_event(log, self.user) callback(onaccept, form) if form.deleted: return self.logout() if not next: next = self.url(args=request.args) else: next = replace_id(next, form) redirect(next, client_side=self.settings.client_side) return form def run_login_onaccept(self): onaccept = self.settings.login_onaccept if onaccept: form = Storage(dict(vars=self.user)) if not isinstance(onaccept, (list, tuple)): onaccept = [onaccept] for callback in onaccept: callback(form) def is_impersonating(self): return self.is_logged_in() and 'impersonator' in current.session.auth def impersonate(self, user_id=DEFAULT): """ To use this make a POST to `http://..../impersonate request.post_vars.user_id=<id>` Set request.post_vars.user_id to 0 to restore original user. requires impersonator is logged in and:: has_permission('impersonate', 'auth_user', user_id) """ request = current.request session = current.session auth = session.auth table_user = self.table_user() if not self.is_logged_in(): raise HTTP(401, "Not Authorized") current_id = auth.user.id requested_id = user_id if user_id is DEFAULT: user_id = current.request.post_vars.user_id if user_id and user_id != self.user.id and user_id != '0': if not self.has_permission('impersonate', self.table_user(), user_id): raise HTTP(403, "Forbidden") user = table_user(user_id) if not user: raise HTTP(401, "Not Authorized") auth.impersonator = pickle.dumps(session, pickle.HIGHEST_PROTOCOL) auth.user.update( table_user._filter_fields(user, True)) self.user = auth.user self.update_groups() log = self.messages['impersonate_log'] self.log_event(log, dict(id=current_id, other_id=auth.user.id)) self.run_login_onaccept() elif user_id in (0, '0'): if self.is_impersonating(): session.clear() session.update(pickle.loads(auth.impersonator)) self.user = session.auth.user self.update_groups() self.run_login_onaccept() return None if requested_id is DEFAULT and not request.post_vars: return SQLFORM.factory(Field('user_id', 'integer')) return SQLFORM(table_user, user.id, readonly=True) def update_groups(self): if not self.user: return user_groups = self.user_groups = {} if current.session.auth: current.session.auth.user_groups = self.user_groups table_group = self.table_group() table_membership = self.table_membership() memberships = self.db( table_membership.user_id == self.user.id).select() for membership in memberships: group = table_group(membership.group_id) if group: user_groups[membership.group_id] = group.role def groups(self): """ Displays the groups and their roles for the logged in user """ if not self.is_logged_in(): redirect(self.settings.login_url) table_membership = self.table_membership() memberships = self.db( table_membership.user_id == self.user.id).select() table = TABLE() for membership in memberships: table_group = self.table_group() groups = self.db(table_group.id == membership.group_id).select() if groups: group = groups[0] table.append(TR(H3(group.role, '(%s)' % group.id))) table.append(TR(P(group.description))) if not memberships: return None return table def not_authorized(self): """ You can change the view for this page to make it look as you like """ if current.request.ajax: raise HTTP(403, 'ACCESS DENIED') return self.messages.access_denied def requires(self, condition, requires_login=True, otherwise=None): """ Decorator that prevents access to action if not logged in """ def decorator(action): def f(*a, **b): basic_allowed, basic_accepted, user = self.basic() user = user or self.user if requires_login: if not user: if current.request.ajax: raise HTTP(401, self.messages.ajax_failed_authentication) elif not otherwise is None: if callable(otherwise): return otherwise() redirect(otherwise) elif self.settings.allow_basic_login_only or \ basic_accepted or current.request.is_restful: raise HTTP(403, "Not authorized") else: next = self.here() current.session.flash = current.response.flash return call_or_redirect( self.settings.on_failed_authentication, self.settings.login_url + '?_next=' + urllib.quote(next)) if callable(condition): flag = condition() else: flag = condition if not flag: current.session.flash = self.messages.access_denied return call_or_redirect( self.settings.on_failed_authorization) return action(*a, **b) f.__doc__ = action.__doc__ f.__name__ = action.__name__ f.__dict__.update(action.__dict__) return f return decorator def requires_login(self, otherwise=None): """ Decorator that prevents access to action if not logged in """ return self.requires(True, otherwise=otherwise) def requires_membership(self, role=None, group_id=None, otherwise=None): """ Decorator that prevents access to action if not logged in or if user logged in is not a member of group_id. If role is provided instead of group_id then the group_id is calculated. """ def has_membership(self=self, group_id=group_id, role=role): return self.has_membership(group_id=group_id, role=role) return self.requires(has_membership, otherwise=otherwise) def requires_permission(self, name, table_name='', record_id=0, otherwise=None): """ Decorator that prevents access to action if not logged in or if user logged in is not a member of any group (role) that has 'name' access to 'table_name', 'record_id'. """ def has_permission(self=self, name=name, table_name=table_name, record_id=record_id): return self.has_permission(name, table_name, record_id) return self.requires(has_permission, otherwise=otherwise) def requires_signature(self, otherwise=None, hash_vars=True): """ Decorator that prevents access to action if not logged in or if user logged in is not a member of group_id. If role is provided instead of group_id then the group_id is calculated. """ def verify(): return URL.verify(current.request, user_signature=True, hash_vars=hash_vars) return self.requires(verify, otherwise) def add_group(self, role, description=''): """ Creates a group associated to a role """ group_id = self.table_group().insert( role=role, description=description) self.log_event(self.messages['add_group_log'], dict(group_id=group_id, role=role)) return group_id def del_group(self, group_id): """ Deletes a group """ self.db(self.table_group().id == group_id).delete() self.db(self.table_membership().group_id == group_id).delete() self.db(self.table_permission().group_id == group_id).delete() if group_id in self.user_groups: del self.user_groups[group_id] self.log_event(self.messages.del_group_log, dict(group_id=group_id)) def id_group(self, role): """ Returns the group_id of the group specified by the role """ rows = self.db(self.table_group().role == role).select() if not rows: return None return rows[0].id def user_group(self, user_id=None): """ Returns the group_id of the group uniquely associated to this user i.e. `role=user:[user_id]` """ return self.id_group(self.user_group_role(user_id)) def user_group_role(self, user_id=None): if not self.settings.create_user_groups: return None if user_id: user = self.table_user()[user_id] else: user = self.user return self.settings.create_user_groups % user def has_membership(self, group_id=None, user_id=None, role=None): """ Checks if user is member of group_id or role """ group_id = group_id or self.id_group(role) try: group_id = int(group_id) except: group_id = self.id_group(group_id) # interpret group_id as a role if not user_id and self.user: user_id = self.user.id membership = self.table_membership() if group_id and user_id and self.db((membership.user_id == user_id) & (membership.group_id == group_id)).select(): r = True else: r = False self.log_event(self.messages['has_membership_log'], dict(user_id=user_id, group_id=group_id, check=r)) return r def add_membership(self, group_id=None, user_id=None, role=None): """ Gives user_id membership of group_id or role if user is None than user_id is that of current logged in user """ group_id = group_id or self.id_group(role) try: group_id = int(group_id) except: group_id = self.id_group(group_id) # interpret group_id as a role if not user_id and self.user: user_id = self.user.id membership = self.table_membership() record = membership(user_id=user_id, group_id=group_id) if record: return record.id else: id = membership.insert(group_id=group_id, user_id=user_id) if role: self.user_groups[group_id] = role else: self.update_groups() self.log_event(self.messages['add_membership_log'], dict(user_id=user_id, group_id=group_id)) return id def del_membership(self, group_id=None, user_id=None, role=None): """ Revokes membership from group_id to user_id if user_id is None than user_id is that of current logged in user """ group_id = group_id or self.id_group(role) if not user_id and self.user: user_id = self.user.id membership = self.table_membership() self.log_event(self.messages['del_membership_log'], dict(user_id=user_id, group_id=group_id)) ret = self.db(membership.user_id == user_id)(membership.group_id == group_id).delete() if group_id in self.user_groups: del self.user_groups[group_id] return ret def has_permission(self, name='any', table_name='', record_id=0, user_id=None, group_id=None, ): """ Checks if user_id or current logged in user is member of a group that has 'name' permission on 'table_name' and 'record_id' if group_id is passed, it checks whether the group has the permission """ if not group_id and self.settings.everybody_group_id and \ self.has_permission( name, table_name, record_id, user_id=None, group_id=self.settings.everybody_group_id): return True if not user_id and not group_id and self.user: user_id = self.user.id if user_id: membership = self.table_membership() rows = self.db(membership.user_id == user_id).select(membership.group_id) groups = set([row.group_id for row in rows]) if group_id and not group_id in groups: return False else: groups = set([group_id]) permission = self.table_permission() rows = self.db(permission.name == name)(permission.table_name == str(table_name))(permission.record_id == record_id).select(permission.group_id) groups_required = set([row.group_id for row in rows]) if record_id: rows = self.db(permission.name == name)(permission.table_name == str(table_name))(permission.record_id == 0).select(permission.group_id) groups_required = groups_required.union(set([row.group_id for row in rows])) if groups.intersection(groups_required): r = True else: r = False if user_id: self.log_event(self.messages['has_permission_log'], dict(user_id=user_id, name=name, table_name=table_name, record_id=record_id)) return r def add_permission(self, group_id, name='any', table_name='', record_id=0, ): """ Gives group_id 'name' access to 'table_name' and 'record_id' """ permission = self.table_permission() if group_id == 0: group_id = self.user_group() record = self.db(permission.group_id == group_id)(permission.name == name)(permission.table_name == str(table_name))( permission.record_id == long(record_id)).select(limitby=(0, 1), orderby_on_limitby=False).first() if record: id = record.id else: id = permission.insert(group_id=group_id, name=name, table_name=str(table_name), record_id=long(record_id)) self.log_event(self.messages['add_permission_log'], dict(permission_id=id, group_id=group_id, name=name, table_name=table_name, record_id=record_id)) return id def del_permission(self, group_id, name='any', table_name='', record_id=0, ): """ Revokes group_id 'name' access to 'table_name' and 'record_id' """ permission = self.table_permission() self.log_event(self.messages['del_permission_log'], dict(group_id=group_id, name=name, table_name=table_name, record_id=record_id)) return self.db(permission.group_id == group_id)(permission.name == name)(permission.table_name == str(table_name))(permission.record_id == long(record_id)).delete() def accessible_query(self, name, table, user_id=None): """ Returns a query with all accessible records for user_id or the current logged in user this method does not work on GAE because uses JOIN and IN Example: Use as:: db(auth.accessible_query('read', db.mytable)).select(db.mytable.ALL) """ if not user_id: user_id = self.user_id db = self.db if isinstance(table, str) and table in self.db.tables(): table = self.db[table] elif isinstance(table, (Set, Query)): # experimental: build a chained query for all tables if isinstance(table, Set): cquery = table.query else: cquery = table tablenames = db._adapter.tables(cquery) for tablename in tablenames: cquery &= self.accessible_query(name, tablename, user_id=user_id) return cquery if not isinstance(table, str) and\ self.has_permission(name, table, 0, user_id): return table.id > 0 membership = self.table_membership() permission = self.table_permission() query = table.id.belongs( db(membership.user_id == user_id) (membership.group_id == permission.group_id) (permission.name == name) (permission.table_name == table) ._select(permission.record_id)) if self.settings.everybody_group_id: query |= table.id.belongs( db(permission.group_id == self.settings.everybody_group_id) (permission.name == name) (permission.table_name == table) ._select(permission.record_id)) return query @staticmethod def archive(form, archive_table=None, current_record='current_record', archive_current=False, fields=None): """ If you have a table (db.mytable) that needs full revision history you can just do:: form=crud.update(db.mytable,myrecord,onaccept=auth.archive) or:: form=SQLFORM(db.mytable,myrecord).process(onaccept=auth.archive) crud.archive will define a new table "mytable_archive" and store a copy of the current record (if archive_current=True) or a copy of the previous record (if archive_current=False) in the newly created table including a reference to the current record. fields allows to specify extra fields that need to be archived. If you want to access such table you need to define it yourself in a model:: db.define_table('mytable_archive', Field('current_record',db.mytable), db.mytable) Notice such table includes all fields of db.mytable plus one: current_record. crud.archive does not timestamp the stored record unless your original table has a fields like:: db.define_table(..., Field('saved_on','datetime', default=request.now,update=request.now,writable=False), Field('saved_by',auth.user, default=auth.user_id,update=auth.user_id,writable=False), there is nothing special about these fields since they are filled before the record is archived. If you want to change the archive table name and the name of the reference field you can do, for example:: db.define_table('myhistory', Field('parent_record',db.mytable), db.mytable) and use it as:: form=crud.update(db.mytable,myrecord, onaccept=lambda form:crud.archive(form, archive_table=db.myhistory, current_record='parent_record')) """ if not archive_current and not form.record: return None table = form.table if not archive_table: archive_table_name = '%s_archive' % table if not archive_table_name in table._db: table._db.define_table( archive_table_name, Field(current_record, table), *[field.clone(unique=False) for field in table]) archive_table = table._db[archive_table_name] new_record = {current_record: form.vars.id} for fieldname in archive_table.fields: if not fieldname in ['id', current_record]: if archive_current and fieldname in form.vars: new_record[fieldname] = form.vars[fieldname] elif form.record and fieldname in form.record: new_record[fieldname] = form.record[fieldname] if fields: new_record.update(fields) id = archive_table.insert(**new_record) return id def wiki(self, slug=None, env=None, render='markmin', manage_permissions=False, force_prefix='', restrict_search=False, resolve=True, extra=None, menu_groups=None, templates=None, migrate=True, controller=None, function=None, force_render=False, groups=None): if controller and function: resolve = False if not hasattr(self, '_wiki'): self._wiki = Wiki(self, render=render, manage_permissions=manage_permissions, force_prefix=force_prefix, restrict_search=restrict_search, env=env, extra=extra or {}, menu_groups=menu_groups, templates=templates, migrate=migrate, controller=controller, function=function, groups=groups) else: self._wiki.env.update(env or {}) # if resolve is set to True, process request as wiki call # resolve=False allows initial setup without wiki redirection wiki = None if resolve: if slug: wiki = self._wiki.read(slug, force_render) if isinstance(wiki, dict) and wiki.has_key('content'): # FIXME: .has_key() is deprecated # We don't want to return a dict object, just the wiki wiki = wiki['content'] else: wiki = self._wiki() if isinstance(wiki, basestring): wiki = XML(wiki) return wiki def wikimenu(self): """To be used in menu.py for app wide wiki menus""" if (hasattr(self, "_wiki") and self._wiki.settings.controller and self._wiki.settings.function): self._wiki.automenu() class Crud(object): def url(self, f=None, args=None, vars=None): """ This should point to the controller that exposes download and crud """ if args is None: args = [] if vars is None: vars = {} return URL(c=self.settings.controller, f=f, args=args, vars=vars) def __init__(self, environment, db=None, controller='default'): self.db = db if not db and environment and isinstance(environment, DAL): self.db = environment elif not db: raise SyntaxError("must pass db as first or second argument") self.environment = current settings = self.settings = Settings() settings.auth = None settings.logger = None settings.create_next = None settings.update_next = None settings.controller = controller settings.delete_next = self.url() settings.download_url = self.url('download') settings.create_onvalidation = StorageList() settings.update_onvalidation = StorageList() settings.delete_onvalidation = StorageList() settings.create_onaccept = StorageList() settings.update_onaccept = StorageList() settings.update_ondelete = StorageList() settings.delete_onaccept = StorageList() settings.update_deletable = True settings.showid = False settings.keepvalues = False settings.create_captcha = None settings.update_captcha = None settings.captcha = None settings.formstyle = 'table3cols' settings.label_separator = ': ' settings.hideerror = False settings.detect_record_change = True settings.hmac_key = None settings.lock_keys = True messages = self.messages = Messages(current.T) messages.submit_button = 'Submit' messages.delete_label = 'Check to delete' messages.record_created = 'Record Created' messages.record_updated = 'Record Updated' messages.record_deleted = 'Record Deleted' messages.update_log = 'Record %(id)s updated' messages.create_log = 'Record %(id)s created' messages.read_log = 'Record %(id)s read' messages.delete_log = 'Record %(id)s deleted' messages.lock_keys = True def __call__(self): args = current.request.args if len(args) < 1: raise HTTP(404) elif args[0] == 'tables': return self.tables() elif len(args) > 1 and not args(1) in self.db.tables: raise HTTP(404) table = self.db[args(1)] if args[0] == 'create': return self.create(table) elif args[0] == 'select': return self.select(table, linkto=self.url(args='read')) elif args[0] == 'search': form, rows = self.search(table, linkto=self.url(args='read')) return DIV(form, SQLTABLE(rows)) elif args[0] == 'read': return self.read(table, args(2)) elif args[0] == 'update': return self.update(table, args(2)) elif args[0] == 'delete': return self.delete(table, args(2)) else: raise HTTP(404) def log_event(self, message, vars): if self.settings.logger: self.settings.logger.log_event(message, vars, origin='crud') def has_permission(self, name, table, record=0): if not self.settings.auth: return True try: record_id = record.id except: record_id = record return self.settings.auth.has_permission(name, str(table), record_id) def tables(self): return TABLE(*[TR(A(name, _href=self.url(args=('select', name)))) for name in self.db.tables]) @staticmethod def archive(form, archive_table=None, current_record='current_record'): return Auth.archive(form, archive_table=archive_table, current_record=current_record) def update(self, table, record, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, ondelete=DEFAULT, log=DEFAULT, message=DEFAULT, deletable=DEFAULT, formname=DEFAULT, **attributes ): if not (isinstance(table, Table) or table in self.db.tables) \ or (isinstance(record, str) and not str(record).isdigit()): raise HTTP(404) if not isinstance(table, Table): table = self.db[table] try: record_id = record.id except: record_id = record or 0 if record_id and not self.has_permission('update', table, record_id): redirect(self.settings.auth.settings.on_failed_authorization) if not record_id and not self.has_permission('create', table, record_id): redirect(self.settings.auth.settings.on_failed_authorization) request = current.request response = current.response session = current.session if request.extension == 'json' and request.vars.json: request.vars.update(json_parser.loads(request.vars.json)) if next is DEFAULT: next = request.get_vars._next \ or request.post_vars._next \ or self.settings.update_next if onvalidation is DEFAULT: onvalidation = self.settings.update_onvalidation if onaccept is DEFAULT: onaccept = self.settings.update_onaccept if ondelete is DEFAULT: ondelete = self.settings.update_ondelete if log is DEFAULT: log = self.messages['update_log'] if deletable is DEFAULT: deletable = self.settings.update_deletable if message is DEFAULT: message = self.messages.record_updated if not 'hidden' in attributes: attributes['hidden'] = {} attributes['hidden']['_next'] = next form = SQLFORM( table, record, showid=self.settings.showid, submit_button=self.messages.submit_button, delete_label=self.messages.delete_label, deletable=deletable, upload=self.settings.download_url, formstyle=self.settings.formstyle, separator=self.settings.label_separator, **attributes # contains hidden ) self.accepted = False self.deleted = False captcha = self.settings.update_captcha or self.settings.captcha if record and captcha: addrow(form, captcha.label, captcha, captcha.comment, self.settings.formstyle, 'captcha__row') captcha = self.settings.create_captcha or self.settings.captcha if not record and captcha: addrow(form, captcha.label, captcha, captcha.comment, self.settings.formstyle, 'captcha__row') if not request.extension in ('html', 'load'): (_session, _formname) = (None, None) else: (_session, _formname) = ( session, '%s/%s' % (table._tablename, form.record_id)) if not formname is DEFAULT: _formname = formname keepvalues = self.settings.keepvalues if request.vars.delete_this_record: keepvalues = False if isinstance(onvalidation, StorageList): onvalidation = onvalidation.get(table._tablename, []) if form.accepts(request, _session, formname=_formname, onvalidation=onvalidation, keepvalues=keepvalues, hideerror=self.settings.hideerror, detect_record_change=self.settings.detect_record_change): self.accepted = True response.flash = message if log: self.log_event(log, form.vars) if request.vars.delete_this_record: self.deleted = True message = self.messages.record_deleted callback(ondelete, form, table._tablename) response.flash = message callback(onaccept, form, table._tablename) if not request.extension in ('html', 'load'): raise HTTP(200, 'RECORD CREATED/UPDATED') if isinstance(next, (list, tuple)): # fix issue with 2.6 next = next[0] if next: # Only redirect when explicit next = replace_id(next, form) session.flash = response.flash redirect(next) elif not request.extension in ('html', 'load'): raise HTTP(401, serializers.json(dict(errors=form.errors))) return form def create(self, table, next=DEFAULT, onvalidation=DEFAULT, onaccept=DEFAULT, log=DEFAULT, message=DEFAULT, formname=DEFAULT, **attributes ): if next is DEFAULT: next = self.settings.create_next if onvalidation is DEFAULT: onvalidation = self.settings.create_onvalidation if onaccept is DEFAULT: onaccept = self.settings.create_onaccept if log is DEFAULT: log = self.messages['create_log'] if message is DEFAULT: message = self.messages.record_created return self.update( table, None, next=next, onvalidation=onvalidation, onaccept=onaccept, log=log, message=message, deletable=False, formname=formname, **attributes ) def read(self, table, record): if not (isinstance(table, Table) or table in self.db.tables) \ or (isinstance(record, str) and not str(record).isdigit()): raise HTTP(404) if not isinstance(table, Table): table = self.db[table] if not self.has_permission('read', table, record): redirect(self.settings.auth.settings.on_failed_authorization) form = SQLFORM( table, record, readonly=True, comments=False, upload=self.settings.download_url, showid=self.settings.showid, formstyle=self.settings.formstyle, separator=self.settings.label_separator ) if not current.request.extension in ('html', 'load'): return table._filter_fields(form.record, id=True) return form def delete(self, table, record_id, next=DEFAULT, message=DEFAULT, ): if not (isinstance(table, Table) or table in self.db.tables): raise HTTP(404) if not isinstance(table, Table): table = self.db[table] if not self.has_permission('delete', table, record_id): redirect(self.settings.auth.settings.on_failed_authorization) request = current.request session = current.session if next is DEFAULT: next = request.get_vars._next \ or request.post_vars._next \ or self.settings.delete_next if message is DEFAULT: message = self.messages.record_deleted record = table[record_id] if record: callback(self.settings.delete_onvalidation, record) del table[record_id] callback(self.settings.delete_onaccept, record, table._tablename) session.flash = message redirect(next) def rows( self, table, query=None, fields=None, orderby=None, limitby=None, ): if not (isinstance(table, Table) or table in self.db.tables): raise HTTP(404) if not self.has_permission('select', table): redirect(self.settings.auth.settings.on_failed_authorization) #if record_id and not self.has_permission('select', table): # redirect(self.settings.auth.settings.on_failed_authorization) if not isinstance(table, Table): table = self.db[table] if not query: query = table.id > 0 if not fields: fields = [field for field in table if field.readable] else: fields = [table[f] if isinstance(f, str) else f for f in fields] rows = self.db(query).select(*fields, **dict(orderby=orderby, limitby=limitby)) return rows def select(self, table, query=None, fields=None, orderby=None, limitby=None, headers=None, **attr ): headers = headers or {} rows = self.rows(table, query, fields, orderby, limitby) if not rows: return None # Nicer than an empty table. if not 'upload' in attr: attr['upload'] = self.url('download') if not current.request.extension in ('html', 'load'): return rows.as_list() if not headers: if isinstance(table, str): table = self.db[table] headers = dict((str(k), k.label) for k in table) return SQLTABLE(rows, headers=headers, **attr) def get_format(self, field): rtable = field._db[field.type[10:]] format = rtable.get('_format', None) if format and isinstance(format, str): return format[2:-2] return field.name def get_query(self, field, op, value, refsearch=False): try: if refsearch: format = self.get_format(field) if op == 'equals': if not refsearch: return field == value else: return lambda row: row[field.name][format] == value elif op == 'not equal': if not refsearch: return field != value else: return lambda row: row[field.name][format] != value elif op == 'greater than': if not refsearch: return field > value else: return lambda row: row[field.name][format] > value elif op == 'less than': if not refsearch: return field < value else: return lambda row: row[field.name][format] < value elif op == 'starts with': if not refsearch: return field.like(value + '%') else: return lambda row: str(row[field.name][format]).startswith(value) elif op == 'ends with': if not refsearch: return field.like('%' + value) else: return lambda row: str(row[field.name][format]).endswith(value) elif op == 'contains': if not refsearch: return field.like('%' + value + '%') else: return lambda row: value in row[field.name][format] except: return None def search(self, *tables, **args): """ Creates a search form and its results for a table Examples: Use as:: form, results = crud.search(db.test, queries = ['equals', 'not equal', 'contains'], query_labels={'equals':'Equals', 'not equal':'Not equal'}, fields = ['id','children'], field_labels = { 'id':'ID','children':'Children'}, zero='Please choose', query = (db.test.id > 0)&(db.test.id != 3) ) """ table = tables[0] fields = args.get('fields', table.fields) validate = args.get('validate', True) request = current.request db = self.db if not (isinstance(table, Table) or table in db.tables): raise HTTP(404) attributes = {} for key in ('orderby', 'groupby', 'left', 'distinct', 'limitby', 'cache'): if key in args: attributes[key] = args[key] tbl = TABLE() selected = [] refsearch = [] results = [] showall = args.get('showall', False) if showall: selected = fields chkall = args.get('chkall', False) if chkall: for f in fields: request.vars['chk%s' % f] = 'on' ops = args.get('queries', []) zero = args.get('zero', '') if not ops: ops = ['equals', 'not equal', 'greater than', 'less than', 'starts with', 'ends with', 'contains'] ops.insert(0, zero) query_labels = args.get('query_labels', {}) query = args.get('query', table.id > 0) field_labels = args.get('field_labels', {}) for field in fields: field = table[field] if not field.readable: continue fieldname = field.name chkval = request.vars.get('chk' + fieldname, None) txtval = request.vars.get('txt' + fieldname, None) opval = request.vars.get('op' + fieldname, None) row = TR(TD(INPUT(_type="checkbox", _name="chk" + fieldname, _disabled=(field.type == 'id'), value=(field.type == 'id' or chkval == 'on'))), TD(field_labels.get(fieldname, field.label)), TD(SELECT([OPTION(query_labels.get(op, op), _value=op) for op in ops], _name="op" + fieldname, value=opval)), TD(INPUT(_type="text", _name="txt" + fieldname, _value=txtval, _id='txt' + fieldname, _class=str(field.type)))) tbl.append(row) if request.post_vars and (chkval or field.type == 'id'): if txtval and opval != '': if field.type[0:10] == 'reference ': refsearch.append(self.get_query(field, opval, txtval, refsearch=True)) elif validate: value, error = field.validate(txtval) if not error: ### TODO deal with 'starts with', 'ends with', 'contains' on GAE query &= self.get_query(field, opval, value) else: row[3].append(DIV(error, _class='error')) else: query &= self.get_query(field, opval, txtval) selected.append(field) form = FORM(tbl, INPUT(_type="submit")) if selected: try: results = db(query).select(*selected, **attributes) for r in refsearch: results = results.find(r) except: # hmmm, we should do better here results = None return form, results urllib2.install_opener(urllib2.build_opener(urllib2.HTTPCookieProcessor())) def fetch(url, data=None, headers=None, cookie=Cookie.SimpleCookie(), user_agent='Mozilla/5.0'): headers = headers or {} if not data is None: data = urllib.urlencode(data) if user_agent: headers['User-agent'] = user_agent headers['Cookie'] = ' '.join( ['%s=%s;' % (c.key, c.value) for c in cookie.values()]) try: from google.appengine.api import urlfetch except ImportError: req = urllib2.Request(url, data, headers) html = urllib2.urlopen(req).read() else: method = ((data is None) and urlfetch.GET) or urlfetch.POST while url is not None: response = urlfetch.fetch(url=url, payload=data, method=method, headers=headers, allow_truncated=False, follow_redirects=False, deadline=10) # next request will be a get, so no need to send the data again data = None method = urlfetch.GET # load cookies from the response cookie.load(response.headers.get('set-cookie', '')) url = response.headers.get('location') html = response.content return html regex_geocode = \ re.compile(r"""<geometry>[\W]*?<location>[\W]*?<lat>(?P<la>[^<]*)</lat>[\W]*?<lng>(?P<lo>[^<]*)</lng>[\W]*?</location>""") def geocode(address): try: a = urllib.quote(address) txt = fetch('http://maps.googleapis.com/maps/api/geocode/xml?sensor=false&address=%s' % a) item = regex_geocode.search(txt) (la, lo) = (float(item.group('la')), float(item.group('lo'))) return (la, lo) except: return (0.0, 0.0) def reverse_geocode(lat, lng, lang=None): """ Try to get an approximate address for a given latitude, longitude. """ if not lang: lang = current.T.accepted_language try: return json_parser.loads(fetch('http://maps.googleapis.com/maps/api/geocode/json?latlng=%(lat)s,%(lng)s&language=%(lang)s' % locals()))['results'][0]['formatted_address'] except: return '' def universal_caller(f, *a, **b): c = f.func_code.co_argcount n = f.func_code.co_varnames[:c] defaults = f.func_defaults or [] pos_args = n[0:-len(defaults)] named_args = n[-len(defaults):] arg_dict = {} # Fill the arg_dict with name and value for the submitted, positional values for pos_index, pos_val in enumerate(a[:c]): arg_dict[n[pos_index]] = pos_val # n[pos_index] is the name of the argument # There might be pos_args left, that are sent as named_values. Gather them as well. # If a argument already is populated with values we simply replaces them. for arg_name in pos_args[len(arg_dict):]: if arg_name in b: arg_dict[arg_name] = b[arg_name] if len(arg_dict) >= len(pos_args): # All the positional arguments is found. The function may now be called. # However, we need to update the arg_dict with the values from the named arguments as well. for arg_name in named_args: if arg_name in b: arg_dict[arg_name] = b[arg_name] return f(**arg_dict) # Raise an error, the function cannot be called. raise HTTP(404, "Object does not exist") class Service(object): def __init__(self, environment=None): self.run_procedures = {} self.csv_procedures = {} self.xml_procedures = {} self.rss_procedures = {} self.json_procedures = {} self.jsonrpc_procedures = {} self.jsonrpc2_procedures = {} self.xmlrpc_procedures = {} self.amfrpc_procedures = {} self.amfrpc3_procedures = {} self.soap_procedures = {} def run(self, f): """ Example: Use as:: service = Service() @service.run def myfunction(a, b): return a + b def call(): return service() Then call it with:: wget http://..../app/default/call/run/myfunction?a=3&b=4 """ self.run_procedures[f.__name__] = f return f def csv(self, f): """ Example: Use as:: service = Service() @service.csv def myfunction(a, b): return a + b def call(): return service() Then call it with:: wget http://..../app/default/call/csv/myfunction?a=3&b=4 """ self.run_procedures[f.__name__] = f return f def xml(self, f): """ Example: Use as:: service = Service() @service.xml def myfunction(a, b): return a + b def call(): return service() Then call it with:: wget http://..../app/default/call/xml/myfunction?a=3&b=4 """ self.run_procedures[f.__name__] = f return f def rss(self, f): """ Example: Use as:: service = Service() @service.rss def myfunction(): return dict(title=..., link=..., description=..., created_on=..., entries=[dict(title=..., link=..., description=..., created_on=...]) def call(): return service() Then call it with: wget http://..../app/default/call/rss/myfunction """ self.rss_procedures[f.__name__] = f return f def json(self, f): """ Example: Use as:: service = Service() @service.json def myfunction(a, b): return [{a: b}] def call(): return service() Then call it with:; wget http://..../app/default/call/json/myfunction?a=hello&b=world """ self.json_procedures[f.__name__] = f return f def jsonrpc(self, f): """ Example: Use as:: service = Service() @service.jsonrpc def myfunction(a, b): return a + b def call(): return service() Then call it with: wget http://..../app/default/call/jsonrpc/myfunction?a=hello&b=world """ self.jsonrpc_procedures[f.__name__] = f return f def jsonrpc2(self, f): """ Example: Use as:: service = Service() @service.jsonrpc2 def myfunction(a, b): return a + b def call(): return service() Then call it with: wget --post-data '{"jsonrpc": "2.0", "id": 1, "method": "myfunction", "params": {"a": 1, "b": 2}}' http://..../app/default/call/jsonrpc2 """ self.jsonrpc2_procedures[f.__name__] = f return f def xmlrpc(self, f): """ Example: Use as:: service = Service() @service.xmlrpc def myfunction(a, b): return a + b def call(): return service() The call it with: wget http://..../app/default/call/xmlrpc/myfunction?a=hello&b=world """ self.xmlrpc_procedures[f.__name__] = f return f def amfrpc(self, f): """ Example: Use as:: service = Service() @service.amfrpc def myfunction(a, b): return a + b def call(): return service() Then call it with:: wget http://..../app/default/call/amfrpc/myfunction?a=hello&b=world """ self.amfrpc_procedures[f.__name__] = f return f def amfrpc3(self, domain='default'): """ Example: Use as:: service = Service() @service.amfrpc3('domain') def myfunction(a, b): return a + b def call(): return service() Then call it with: wget http://..../app/default/call/amfrpc3/myfunction?a=hello&b=world """ if not isinstance(domain, str): raise SyntaxError("AMF3 requires a domain for function") def _amfrpc3(f): if domain: self.amfrpc3_procedures[domain + '.' + f.__name__] = f else: self.amfrpc3_procedures[f.__name__] = f return f return _amfrpc3 def soap(self, name=None, returns=None, args=None, doc=None): """ Example: Use as:: service = Service() @service.soap('MyFunction',returns={'result':int},args={'a':int,'b':int,}) def myfunction(a, b): return a + b def call(): return service() Then call it with:: from gluon.contrib.pysimplesoap.client import SoapClient client = SoapClient(wsdl="http://..../app/default/call/soap?WSDL") response = client.MyFunction(a=1,b=2) return response['result'] It also exposes online generated documentation and xml example messages at `http://..../app/default/call/soap` """ def _soap(f): self.soap_procedures[name or f.__name__] = f, returns, args, doc return f return _soap def serve_run(self, args=None): request = current.request if not args: args = request.args if args and args[0] in self.run_procedures: return str(universal_caller(self.run_procedures[args[0]], *args[1:], **dict(request.vars))) self.error() def serve_csv(self, args=None): request = current.request response = current.response response.headers['Content-Type'] = 'text/x-csv' if not args: args = request.args def none_exception(value): if isinstance(value, unicode): return value.encode('utf8') if hasattr(value, 'isoformat'): return value.isoformat()[:19].replace('T', ' ') if value is None: return '<NULL>' return value if args and args[0] in self.run_procedures: import types r = universal_caller(self.run_procedures[args[0]], *args[1:], **dict(request.vars)) s = cStringIO.StringIO() if hasattr(r, 'export_to_csv_file'): r.export_to_csv_file(s) elif r and not isinstance(r, types.GeneratorType) and isinstance(r[0], (dict, Storage)): import csv writer = csv.writer(s) writer.writerow(r[0].keys()) for line in r: writer.writerow([none_exception(v) for v in line.values()]) else: import csv writer = csv.writer(s) for line in r: writer.writerow(line) return s.getvalue() self.error() def serve_xml(self, args=None): request = current.request response = current.response response.headers['Content-Type'] = 'text/xml' if not args: args = request.args if args and args[0] in self.run_procedures: s = universal_caller(self.run_procedures[args[0]], *args[1:], **dict(request.vars)) if hasattr(s, 'as_list'): s = s.as_list() return serializers.xml(s, quote=False) self.error() def serve_rss(self, args=None): request = current.request response = current.response if not args: args = request.args if args and args[0] in self.rss_procedures: feed = universal_caller(self.rss_procedures[args[0]], *args[1:], **dict(request.vars)) else: self.error() response.headers['Content-Type'] = 'application/rss+xml' return serializers.rss(feed) def serve_json(self, args=None): request = current.request response = current.response response.headers['Content-Type'] = 'application/json; charset=utf-8' if not args: args = request.args d = dict(request.vars) if args and args[0] in self.json_procedures: s = universal_caller(self.json_procedures[args[0]], *args[1:], **d) if hasattr(s, 'as_list'): s = s.as_list() return response.json(s) self.error() class JsonRpcException(Exception): def __init__(self, code, info): jrpc_error = Service.jsonrpc_errors.get(code) if jrpc_error: self.message, self.description = jrpc_error self.code, self.info = code, info # jsonrpc 2.0 error types. records the following structure {code: (message,meaning)} jsonrpc_errors = { -32700: ("Parse error. Invalid JSON was received by the server.", "An error occurred on the server while parsing the JSON text."), -32600: ("Invalid Request", "The JSON sent is not a valid Request object."), -32601: ("Method not found", "The method does not exist / is not available."), -32602: ("Invalid params", "Invalid method parameter(s)."), -32603: ("Internal error", "Internal JSON-RPC error."), -32099: ("Server error", "Reserved for implementation-defined server-errors.")} def serve_jsonrpc(self): def return_response(id, result): return serializers.json({'version': '1.1', 'id': id, 'result': result, 'error': None}) def return_error(id, code, message, data=None): error = {'name': 'JSONRPCError', 'code': code, 'message': message} if data is not None: error['data'] = data return serializers.json({'id': id, 'version': '1.1', 'error': error, }) request = current.request response = current.response response.headers['Content-Type'] = 'application/json; charset=utf-8' methods = self.jsonrpc_procedures data = json_parser.loads(request.body.read()) jsonrpc_2 = data.get('jsonrpc') if jsonrpc_2: #hand over to version 2 of the protocol return self.serve_jsonrpc2(data) id, method, params = data.get('id'), data.get('method'), data.get('params', []) if id is None: return return_error(0, 100, 'missing id') if not method in methods: return return_error(id, 100, 'method "%s" does not exist' % method) try: if isinstance(params, dict): s = methods[method](**params) else: s = methods[method](*params) if hasattr(s, 'as_list'): s = s.as_list() return return_response(id, s) except Service.JsonRpcException, e: return return_error(id, e.code, e.info) except: etype, eval, etb = sys.exc_info() message = '%s: %s' % (etype.__name__, eval) data = request.is_local and traceback.format_tb(etb) logger.warning('jsonrpc exception %s\n%s' % (message, traceback.format_tb(etb))) return return_error(id, 100, message, data) def serve_jsonrpc2(self, data=None, batch_element=False): def return_response(id, result): if not must_respond: return None return serializers.json({'jsonrpc': '2.0', 'id': id, 'result': result}) def return_error(id, code, message=None, data=None): error = {'code': code} if Service.jsonrpc_errors.has_key(code): error['message'] = Service.jsonrpc_errors[code][0] error['data'] = Service.jsonrpc_errors[code][1] if message is not None: error['message'] = message if data is not None: error['data'] = data return serializers.json({'jsonrpc': '2.0', 'id': id, 'error': error}) def validate(data): """ Validate request as defined in: http://www.jsonrpc.org/specification#request_object. Args: data(str): The json object. Returns: - True -- if successful - False -- if no error should be reported (i.e. data is missing 'id' member) Raises: JsonRPCException """ iparms = set(data.keys()) mandatory_args = set(['jsonrpc', 'method']) missing_args = mandatory_args - iparms if missing_args: raise Service.JsonRpcException(-32600, 'Missing arguments %s.' % list(missing_args)) if data['jsonrpc'] != '2.0': raise Service.JsonRpcException(-32603, 'Unsupported jsonrpc version "%s"' % data['jsonrpc']) if 'id' not in iparms: return False return True request = current.request response = current.response if not data: response.headers['Content-Type'] = 'application/json; charset=utf-8' try: data = json_parser.loads(request.body.read()) except ValueError: # decoding error in json lib return return_error(None, -32700) # Batch handling if isinstance(data, list) and not batch_element: retlist = [] for c in data: retstr = self.serve_jsonrpc2(c, batch_element=True) if retstr: # do not add empty responses retlist.append(retstr) if len(retlist) == 0: # return nothing return '' else: return "[" + ','.join(retlist) + "]" methods = self.jsonrpc2_procedures methods.update(self.jsonrpc_procedures) try: must_respond = validate(data) except Service.JsonRpcException, e: return return_error(None, e.code, e.info) id, method, params = data.get('id'), data['method'], data.get('params', '') if not method in methods: return return_error(id, -32601, data='Method "%s" does not exist' % method) try: if isinstance(params, dict): s = methods[method](**params) else: s = methods[method](*params) if hasattr(s, 'as_list'): s = s.as_list() if must_respond: return return_response(id, s) else: return '' except HTTP, e: raise e except Service.JsonRpcException, e: return return_error(id, e.code, e.info) except: etype, eval, etb = sys.exc_info() data = '%s: %s\n' % (etype.__name__, eval) + str(request.is_local and traceback.format_tb(etb)) logger.warning('%s: %s\n%s' % (etype.__name__, eval, traceback.format_tb(etb))) return return_error(id, -32099, data=data) def serve_xmlrpc(self): request = current.request response = current.response services = self.xmlrpc_procedures.values() return response.xmlrpc(request, services) def serve_amfrpc(self, version=0): try: import pyamf import pyamf.remoting.gateway except: return "pyamf not installed or not in Python sys.path" request = current.request response = current.response if version == 3: services = self.amfrpc3_procedures base_gateway = pyamf.remoting.gateway.BaseGateway(services) pyamf_request = pyamf.remoting.decode(request.body) else: services = self.amfrpc_procedures base_gateway = pyamf.remoting.gateway.BaseGateway(services) context = pyamf.get_context(pyamf.AMF0) pyamf_request = pyamf.remoting.decode(request.body, context) pyamf_response = pyamf.remoting.Envelope(pyamf_request.amfVersion) for name, message in pyamf_request: pyamf_response[name] = base_gateway.getProcessor(message)(message) response.headers['Content-Type'] = pyamf.remoting.CONTENT_TYPE if version == 3: return pyamf.remoting.encode(pyamf_response).getvalue() else: return pyamf.remoting.encode(pyamf_response, context).getvalue() def serve_soap(self, version="1.1"): try: from gluon.contrib.pysimplesoap.server import SoapDispatcher except: return "pysimplesoap not installed in contrib" request = current.request response = current.response procedures = self.soap_procedures location = "%s://%s%s" % ( request.env.wsgi_url_scheme, request.env.http_host, URL(r=request, f="call/soap", vars={})) namespace = 'namespace' in response and response.namespace or location documentation = response.description or '' dispatcher = SoapDispatcher( name=response.title, location=location, action=location, # SOAPAction namespace=namespace, prefix='pys', documentation=documentation, ns=True) for method, (function, returns, args, doc) in procedures.iteritems(): dispatcher.register_function(method, function, returns, args, doc) if request.env.request_method == 'POST': fault = {} # Process normal Soap Operation response.headers['Content-Type'] = 'text/xml' xml = dispatcher.dispatch(request.body.read(), fault=fault) if fault: # May want to consider populating a ticket here... response.status = 500 # return the soap response return xml elif 'WSDL' in request.vars: # Return Web Service Description response.headers['Content-Type'] = 'text/xml' return dispatcher.wsdl() elif 'op' in request.vars: # Return method help webpage response.headers['Content-Type'] = 'text/html' method = request.vars['op'] sample_req_xml, sample_res_xml, doc = dispatcher.help(method) body = [H1("Welcome to Web2Py SOAP webservice gateway"), A("See all webservice operations", _href=URL(r=request, f="call/soap", vars={})), H2(method), P(doc), UL(LI("Location: %s" % dispatcher.location), LI("Namespace: %s" % dispatcher.namespace), LI("SoapAction: %s" % dispatcher.action), ), H3("Sample SOAP XML Request Message:"), CODE(sample_req_xml, language="xml"), H3("Sample SOAP XML Response Message:"), CODE(sample_res_xml, language="xml"), ] return {'body': body} else: # Return general help and method list webpage response.headers['Content-Type'] = 'text/html' body = [H1("Welcome to Web2Py SOAP webservice gateway"), P(response.description), P("The following operations are available"), A("See WSDL for webservice description", _href=URL(r=request, f="call/soap", vars={"WSDL":None})), UL([LI(A("%s: %s" % (method, doc or ''), _href=URL(r=request, f="call/soap", vars={'op': method}))) for method, doc in dispatcher.list_methods()]), ] return {'body': body} def __call__(self): """ Registers services with:: service = Service() @service.run @service.rss @service.json @service.jsonrpc @service.xmlrpc @service.amfrpc @service.amfrpc3('domain') @service.soap('Method', returns={'Result':int}, args={'a':int,'b':int,}) Exposes services with:: def call(): return service() You can call services with:: http://..../app/default/call/run?[parameters] http://..../app/default/call/rss?[parameters] http://..../app/default/call/json?[parameters] http://..../app/default/call/jsonrpc http://..../app/default/call/xmlrpc http://..../app/default/call/amfrpc http://..../app/default/call/amfrpc3 http://..../app/default/call/soap """ request = current.request if len(request.args) < 1: raise HTTP(404, "Not Found") arg0 = request.args(0) if arg0 == 'run': return self.serve_run(request.args[1:]) elif arg0 == 'rss': return self.serve_rss(request.args[1:]) elif arg0 == 'csv': return self.serve_csv(request.args[1:]) elif arg0 == 'xml': return self.serve_xml(request.args[1:]) elif arg0 == 'json': return self.serve_json(request.args[1:]) elif arg0 == 'jsonrpc': return self.serve_jsonrpc() elif arg0 == 'jsonrpc2': return self.serve_jsonrpc2() elif arg0 == 'xmlrpc': return self.serve_xmlrpc() elif arg0 == 'amfrpc': return self.serve_amfrpc() elif arg0 == 'amfrpc3': return self.serve_amfrpc(3) elif arg0 == 'soap': return self.serve_soap() else: self.error() def error(self): raise HTTP(404, "Object does not exist") def completion(callback): """ Executes a task on completion of the called action. Example: Use as:: from gluon.tools import completion @completion(lambda d: logging.info(repr(d))) def index(): return dict(message='hello') It logs the output of the function every time input is called. The argument of completion is executed in a new thread. """ def _completion(f): def __completion(*a, **b): d = None try: d = f(*a, **b) return d finally: thread.start_new_thread(callback, (d,)) return __completion return _completion def prettydate(d, T=lambda x: x): if isinstance(d, datetime.datetime): dt = datetime.datetime.now() - d elif isinstance(d, datetime.date): dt = datetime.date.today() - d elif not d: return '' else: return '[invalid date]' if dt.days < 0: suffix = ' from now' dt = -dt else: suffix = ' ago' if dt.days >= 2 * 365: return T('%d years' + suffix) % int(dt.days / 365) elif dt.days >= 365: return T('1 year' + suffix) elif dt.days >= 60: return T('%d months' + suffix) % int(dt.days / 30) elif dt.days > 21: return T('1 month' + suffix) elif dt.days >= 14: return T('%d weeks' + suffix) % int(dt.days / 7) elif dt.days >= 7: return T('1 week' + suffix) elif dt.days > 1: return T('%d days' + suffix) % dt.days elif dt.days == 1: return T('1 day' + suffix) elif dt.seconds >= 2 * 60 * 60: return T('%d hours' + suffix) % int(dt.seconds / 3600) elif dt.seconds >= 60 * 60: return T('1 hour' + suffix) elif dt.seconds >= 2 * 60: return T('%d minutes' + suffix) % int(dt.seconds / 60) elif dt.seconds >= 60: return T('1 minute' + suffix) elif dt.seconds > 1: return T('%d seconds' + suffix) % dt.seconds elif dt.seconds == 1: return T('1 second' + suffix) else: return T('now') def test_thread_separation(): def f(): c = PluginManager() lock1.acquire() lock2.acquire() c.x = 7 lock1.release() lock2.release() lock1 = thread.allocate_lock() lock2 = thread.allocate_lock() lock1.acquire() thread.start_new_thread(f, ()) a = PluginManager() a.x = 5 lock1.release() lock2.acquire() return a.x class PluginManager(object): """ Plugin Manager is similar to a storage object but it is a single level singleton. This means that multiple instances within the same thread share the same attributes. Its constructor is also special. The first argument is the name of the plugin you are defining. The named arguments are parameters needed by the plugin with default values. If the parameters were previous defined, the old values are used. Example: in some general configuration file:: plugins = PluginManager() plugins.me.param1=3 within the plugin model:: _ = PluginManager('me',param1=5,param2=6,param3=7) where the plugin is used:: >>> print plugins.me.param1 3 >>> print plugins.me.param2 6 >>> plugins.me.param3 = 8 >>> print plugins.me.param3 8 Here are some tests:: >>> a=PluginManager() >>> a.x=6 >>> b=PluginManager('check') >>> print b.x 6 >>> b=PluginManager() # reset settings >>> print b.x <Storage {}> >>> b.x=7 >>> print a.x 7 >>> a.y.z=8 >>> print b.y.z 8 >>> test_thread_separation() 5 >>> plugins=PluginManager('me',db='mydb') >>> print plugins.me.db mydb >>> print 'me' in plugins True >>> print plugins.me.installed True """ instances = {} def __new__(cls, *a, **b): id = thread.get_ident() lock = thread.allocate_lock() try: lock.acquire() try: return cls.instances[id] except KeyError: instance = object.__new__(cls, *a, **b) cls.instances[id] = instance return instance finally: lock.release() def __init__(self, plugin=None, **defaults): if not plugin: self.__dict__.clear() settings = self.__getattr__(plugin) settings.installed = True settings.update( (k, v) for k, v in defaults.items() if not k in settings) def __getattr__(self, key): if not key in self.__dict__: self.__dict__[key] = Storage() return self.__dict__[key] def keys(self): return self.__dict__.keys() def __contains__(self, key): return key in self.__dict__ class Expose(object): def __init__(self, base=None, basename=None, extensions=None, allow_download=True): """ Examples: Use as:: def static(): return dict(files=Expose()) or:: def static(): path = os.path.join(request.folder,'static','public') return dict(files=Expose(path,basename='public')) Args: extensions: an optional list of file extensions for filtering displayed files: e.g. `['.py', '.jpg']` allow_download: whether to allow downloading selected files """ current.session.forget() base = base or os.path.join(current.request.folder, 'static') basename = basename or current.request.function self.basename = basename if current.request.raw_args: self.args = [arg for arg in current.request.raw_args.split('/') if arg] else: self.args = [arg for arg in current.request.args if arg] filename = os.path.join(base, *self.args) if not os.path.exists(filename): raise HTTP(404, "FILE NOT FOUND") if not os.path.normpath(filename).startswith(base): raise HTTP(401, "NOT AUTHORIZED") if allow_download and not os.path.isdir(filename): current.response.headers['Content-Type'] = contenttype(filename) raise HTTP(200, open(filename, 'rb'), **current.response.headers) self.path = path = os.path.join(filename, '*') self.folders = [f[len(path) - 1:] for f in sorted(glob.glob(path)) if os.path.isdir(f) and not self.isprivate(f)] self.filenames = [f[len(path) - 1:] for f in sorted(glob.glob(path)) if not os.path.isdir(f) and not self.isprivate(f)] if 'README' in self.filenames: readme = open(os.path.join(filename, 'README')).read() self.paragraph = MARKMIN(readme) else: self.paragraph = None if extensions: self.filenames = [f for f in self.filenames if os.path.splitext(f)[-1] in extensions] def breadcrumbs(self, basename): path = [] span = SPAN() span.append(A(basename, _href=URL())) for arg in self.args: span.append('/') path.append(arg) span.append(A(arg, _href=URL(args='/'.join(path)))) return span def table_folders(self): if self.folders: return SPAN(H3('Folders'), TABLE( *[TR(TD(A(folder, _href=URL(args=self.args + [folder])))) for folder in self.folders], **dict(_class="table"))) return '' @staticmethod def isprivate(f): return 'private' in f or f.startswith('.') or f.endswith('~') @staticmethod def isimage(f): return os.path.splitext(f)[-1].lower() in ( '.png', '.jpg', '.jpeg', '.gif', '.tiff') def table_files(self, width=160): if self.filenames: return SPAN(H3('Files'), TABLE(*[TR(TD(A(f, _href=URL(args=self.args + [f]))), TD(IMG(_src=URL(args=self.args + [f]), _style='max-width:%spx' % width) if width and self.isimage(f) else '')) for f in self.filenames], **dict(_class="table"))) return '' def xml(self): return DIV( H2(self.breadcrumbs(self.basename)), self.paragraph or '', self.table_folders(), self.table_files()).xml() class Wiki(object): everybody = 'everybody' rows_page = 25 def markmin_base(self, body): return MARKMIN(body, extra=self.settings.extra, url=True, environment=self.env, autolinks=lambda link: expand_one(link, {})).xml() def render_tags(self, tags): return DIV( _class='w2p_wiki_tags', *[A(t.strip(), _href=URL(args='_search', vars=dict(q=t))) for t in tags or [] if t.strip()]) def markmin_render(self, page): return self.markmin_base(page.body) + self.render_tags(page.tags).xml() def html_render(self, page): html = page.body # @///function -> http://..../function html = replace_at_urls(html, URL) # http://...jpg -> <img src="http://...jpg/> or embed html = replace_autolinks(html, lambda link: expand_one(link, {})) # @{component:name} -> <script>embed component name</script> html = replace_components(html, self.env) html = html + self.render_tags(page.tags).xml() return html @staticmethod def component(text): """ In wiki docs allows `@{component:controller/function/args}` which renders as a `LOAD(..., ajax=True)` """ items = text.split('/') controller, function, args = items[0], items[1], items[2:] return LOAD(controller, function, args=args, ajax=True).xml() def get_renderer(self): if isinstance(self.settings.render, basestring): r = getattr(self, "%s_render" % self.settings.render) elif callable(self.settings.render): r = self.settings.render elif isinstance(self.settings.render, dict): def custom_render(page): if page.render: if page.render in self.settings.render.keys(): my_render = self.settings.render[page.render] else: my_render = getattr(self, "%s_render" % page.render) else: my_render = self.markmin_render return my_render(page) r = custom_render else: raise ValueError( "Invalid render type %s" % type(self.settings.render)) return r def __init__(self, auth, env=None, render='markmin', manage_permissions=False, force_prefix='', restrict_search=False, extra=None, menu_groups=None, templates=None, migrate=True, controller=None, function=None, groups=None): settings = self.settings = auth.settings.wiki """ Args: render: - "markmin" - "html" - `<function>` : Sets a custom render function - `dict(html=<function>, markmin=...)`: dict(...) allows multiple custom render functions - "multiple" : Is the same as `{}`. It enables per-record formats using builtins """ engines = set(['markmin', 'html']) show_engine = False if render == "multiple": render = {} if isinstance(render, dict): [engines.add(key) for key in render] show_engine = True settings.render = render perms = settings.manage_permissions = manage_permissions settings.force_prefix = force_prefix settings.restrict_search = restrict_search settings.extra = extra or {} settings.menu_groups = menu_groups settings.templates = templates settings.controller = controller settings.function = function settings.groups = auth.user_groups.values() \ if groups is None else groups db = auth.db self.env = env or {} self.env['component'] = Wiki.component self.auth = auth self.wiki_menu_items = None if self.auth.user: self.settings.force_prefix = force_prefix % self.auth.user else: self.settings.force_prefix = force_prefix self.host = current.request.env.http_host table_definitions = [ ('wiki_page', { 'args': [ Field('slug', requires=[IS_SLUG(), IS_NOT_IN_DB(db, 'wiki_page.slug')], writable=False), Field('title', length=255, unique=True), Field('body', 'text', notnull=True), Field('tags', 'list:string'), Field('can_read', 'list:string', writable=perms, readable=perms, default=[Wiki.everybody]), Field('can_edit', 'list:string', writable=perms, readable=perms, default=[Wiki.everybody]), Field('changelog'), Field('html', 'text', compute=self.get_renderer(), readable=False, writable=False), Field('render', default="markmin", readable=show_engine, writable=show_engine, requires=IS_EMPTY_OR( IS_IN_SET(engines))), auth.signature], 'vars': {'format': '%(title)s', 'migrate': migrate}}), ('wiki_tag', { 'args': [ Field('name'), Field('wiki_page', 'reference wiki_page'), auth.signature], 'vars':{'format': '%(title)s', 'migrate': migrate}}), ('wiki_media', { 'args': [ Field('wiki_page', 'reference wiki_page'), Field('title', required=True), Field('filename', 'upload', required=True), auth.signature], 'vars': {'format': '%(title)s', 'migrate': migrate}}), ] # define only non-existent tables for key, value in table_definitions: args = [] if not key in db.tables(): # look for wiki_ extra fields in auth.settings extra_fields = auth.settings.extra_fields if extra_fields: if key in extra_fields: if extra_fields[key]: for field in extra_fields[key]: args.append(field) args += value['args'] db.define_table(key, *args, **value['vars']) if self.settings.templates is None and not \ self.settings.manage_permissions: self.settings.templates = db.wiki_page.tags.contains('template') & \ db.wiki_page.can_read.contains('everybody') def update_tags_insert(page, id, db=db): for tag in page.tags or []: tag = tag.strip().lower() if tag: db.wiki_tag.insert(name=tag, wiki_page=id) def update_tags_update(dbset, page, db=db): page = dbset.select(limitby=(0, 1)).first() db(db.wiki_tag.wiki_page == page.id).delete() for tag in page.tags or []: tag = tag.strip().lower() if tag: db.wiki_tag.insert(name=tag, wiki_page=page.id) db.wiki_page._after_insert.append(update_tags_insert) db.wiki_page._after_update.append(update_tags_update) if (auth.user and check_credentials(current.request, gae_login=False) and not 'wiki_editor' in auth.user_groups.values() and self.settings.groups == auth.user_groups.values()): group = db.auth_group(role='wiki_editor') gid = group.id if group else db.auth_group.insert( role='wiki_editor') auth.add_membership(gid) settings.lock_keys = True # WIKI ACCESS POLICY def not_authorized(self, page=None): raise HTTP(401) def can_read(self, page): if 'everybody' in page.can_read or not \ self.settings.manage_permissions: return True elif self.auth.user: groups = self.settings.groups if ('wiki_editor' in groups or set(groups).intersection(set(page.can_read + page.can_edit)) or page.created_by == self.auth.user.id): return True return False def can_edit(self, page=None): if not self.auth.user: redirect(self.auth.settings.login_url) groups = self.settings.groups return ('wiki_editor' in groups or (page is None and 'wiki_author' in groups) or not page is None and ( set(groups).intersection(set(page.can_edit)) or page.created_by == self.auth.user.id)) def can_manage(self): if not self.auth.user: return False groups = self.settings.groups return 'wiki_editor' in groups def can_search(self): return True def can_see_menu(self): if self.auth.user: if self.settings.menu_groups is None: return True else: groups = self.settings.groups if any(t in self.settings.menu_groups for t in groups): return True return False ### END POLICY def automenu(self): """adds the menu if not present""" if (not self.wiki_menu_items and self.settings.controller and self.settings.function): self.wiki_menu_items = self.menu(self.settings.controller, self.settings.function) current.response.menu += self.wiki_menu_items def __call__(self): request = current.request settings = self.settings settings.controller = settings.controller or request.controller settings.function = settings.function or request.function self.automenu() zero = request.args(0) or 'index' if zero and zero.isdigit(): return self.media(int(zero)) elif not zero or not zero.startswith('_'): return self.read(zero) elif zero == '_edit': return self.edit(request.args(1) or 'index', request.args(2) or 0) elif zero == '_editmedia': return self.editmedia(request.args(1) or 'index') elif zero == '_create': return self.create() elif zero == '_pages': return self.pages() elif zero == '_search': return self.search() elif zero == '_recent': ipage = int(request.vars.page or 0) query = self.auth.db.wiki_page.created_by == request.args( 1, cast=int) return self.search(query=query, orderby=~self.auth.db.wiki_page.created_on, limitby=(ipage * self.rows_page, (ipage + 1) * self.rows_page), ) elif zero == '_cloud': return self.cloud() elif zero == '_preview': return self.preview(self.get_renderer()) def first_paragraph(self, page): if not self.can_read(page): mm = (page.body or '').replace('\r', '') ps = [p for p in mm.split('\n\n') if not p.startswith('#') and p.strip()] if ps: return ps[0] return '' def fix_hostname(self, body): return (body or '').replace('://HOSTNAME', '://%s' % self.host) def read(self, slug, force_render=False): if slug in '_cloud': return self.cloud() elif slug in '_search': return self.search() page = self.auth.db.wiki_page(slug=slug) if page and (not self.can_read(page)): return self.not_authorized(page) if current.request.extension == 'html': if not page: url = URL(args=('_create', slug)) return dict(content=A('Create page "%s"' % slug, _href=url, _class="btn")) else: html = page.html if not force_render else self.get_renderer()(page) content = XML(self.fix_hostname(html)) return dict(title=page.title, slug=page.slug, page=page, content=content, tags=page.tags, created_on=page.created_on, modified_on=page.modified_on) elif current.request.extension == 'load': return self.fix_hostname(page.html) if page else '' else: if not page: raise HTTP(404) else: return dict(title=page.title, slug=page.slug, page=page, content=page.body, tags=page.tags, created_on=page.created_on, modified_on=page.modified_on) def edit(self, slug, from_template=0): auth = self.auth db = auth.db page = db.wiki_page(slug=slug) if not self.can_edit(page): return self.not_authorized(page) title_guess = ' '.join(c.capitalize() for c in slug.split('-')) if not page: if not (self.can_manage() or slug.startswith(self.settings.force_prefix)): current.session.flash = 'slug must have "%s" prefix' \ % self.settings.force_prefix redirect(URL(args=('_create'))) db.wiki_page.can_read.default = [Wiki.everybody] db.wiki_page.can_edit.default = [auth.user_group_role()] db.wiki_page.title.default = title_guess db.wiki_page.slug.default = slug if slug == 'wiki-menu': db.wiki_page.body.default = \ '- Menu Item > @////index\n- - Submenu > http://web2py.com' else: db.wiki_page.body.default = db(db.wiki_page.id == from_template).select(db.wiki_page.body)[0].body \ if int(from_template) > 0 else '## %s\n\npage content' % title_guess vars = current.request.post_vars if vars.body: vars.body = vars.body.replace('://%s' % self.host, '://HOSTNAME') form = SQLFORM(db.wiki_page, page, deletable=True, formstyle='table2cols', showid=False).process() if form.deleted: current.session.flash = 'page deleted' redirect(URL()) elif form.accepted: current.session.flash = 'page created' redirect(URL(args=slug)) script = """ jQuery(function() { if (!jQuery('#wiki_page_body').length) return; var pagecontent = jQuery('#wiki_page_body'); pagecontent.css('font-family', 'Monaco,Menlo,Consolas,"Courier New",monospace'); var prevbutton = jQuery('<button class="btn nopreview">Preview</button>'); var preview = jQuery('<div id="preview"></div>').hide(); var previewmedia = jQuery('<div id="previewmedia"></div>'); var form = pagecontent.closest('form'); preview.insertBefore(form); prevbutton.insertBefore(form); if(%(link_media)s) { var mediabutton = jQuery('<button class="btn nopreview">Media</button>'); mediabutton.insertBefore(form); previewmedia.insertBefore(form); mediabutton.click(function() { if (mediabutton.hasClass('nopreview')) { web2py_component('%(urlmedia)s', 'previewmedia'); } else { previewmedia.empty(); } mediabutton.toggleClass('nopreview'); }); } prevbutton.click(function(e) { e.preventDefault(); if (prevbutton.hasClass('nopreview')) { prevbutton.addClass('preview').removeClass( 'nopreview').html('Edit Source'); try{var wiki_render = jQuery('#wiki_page_render').val()} catch(e){var wiki_render = null;} web2py_ajax_page('post', \ '%(url)s', {body: jQuery('#wiki_page_body').val(), \ render: wiki_render}, 'preview'); form.fadeOut('fast', function() {preview.fadeIn()}); } else { prevbutton.addClass( 'nopreview').removeClass('preview').html('Preview'); preview.fadeOut('fast', function() {form.fadeIn()}); } }) }) """ % dict(url=URL(args=('_preview', slug)), link_media=('true' if page else 'false'), urlmedia=URL(extension='load', args=('_editmedia', slug), vars=dict(embedded=1))) return dict(content=TAG[''](form, SCRIPT(script))) def editmedia(self, slug): auth = self.auth db = auth.db page = db.wiki_page(slug=slug) if not (page and self.can_edit(page)): return self.not_authorized(page) self.auth.db.wiki_media.id.represent = lambda id, row: \ id if not row.filename else \ SPAN('@////%i/%s.%s' % (id, IS_SLUG.urlify(row.title.split('.')[0]), row.filename.split('.')[-1])) self.auth.db.wiki_media.wiki_page.default = page.id self.auth.db.wiki_media.wiki_page.writable = False links = [] csv = True create = True if current.request.vars.embedded: script = "var c = jQuery('#wiki_page_body'); c.val(c.val() + jQuery('%s').text()); return false;" fragment = self.auth.db.wiki_media.id.represent csv = False create = False links= [ lambda row: A('copy into source', _href='#', _onclick=script % (fragment(row.id, row))) ] content = SQLFORM.grid( self.auth.db.wiki_media.wiki_page == page.id, orderby=self.auth.db.wiki_media.title, links=links, csv=csv, create=create, args=['_editmedia', slug], user_signature=False) return dict(content=content) def create(self): if not self.can_edit(): return self.not_authorized() db = self.auth.db slugs = db(db.wiki_page.id > 0).select(db.wiki_page.id, db.wiki_page.slug) options = [OPTION(row.slug, _value=row.id) for row in slugs] options.insert(0, OPTION('', _value='')) fields = [Field("slug", default=current.request.args(1) or self.settings.force_prefix, requires=(IS_SLUG(), IS_NOT_IN_DB(db, db.wiki_page.slug))),] if self.settings.templates: fields.append( Field("from_template", "reference wiki_page", requires=IS_EMPTY_OR( IS_IN_DB(db(self.settings.templates), db.wiki_page._id, '%(slug)s')), comment=current.T( "Choose Template or empty for new Page"))) form = SQLFORM.factory(*fields, **dict(_class="well")) form.element("[type=submit]").attributes["_value"] = \ current.T("Create Page from Slug") if form.process().accepted: form.vars.from_template = 0 if not form.vars.from_template \ else form.vars.from_template redirect(URL(args=('_edit', form.vars.slug, form.vars.from_template or 0))) # added param return dict(content=form) def pages(self): if not self.can_manage(): return self.not_authorized() self.auth.db.wiki_page.slug.represent = lambda slug, row: SPAN( '@////%s' % slug) self.auth.db.wiki_page.title.represent = lambda title, row: \ A(title, _href=URL(args=row.slug)) wiki_table = self.auth.db.wiki_page content = SQLFORM.grid( wiki_table, fields=[wiki_table.slug, wiki_table.title, wiki_table.tags, wiki_table.can_read, wiki_table.can_edit], links=[ lambda row: A('edit', _href=URL(args=('_edit', row.slug)), _class='btn'), lambda row: A('media', _href=URL(args=('_editmedia', row.slug)), _class='btn')], details=False, editable=False, deletable=False, create=False, orderby=self.auth.db.wiki_page.title, args=['_pages'], user_signature=False) return dict(content=content) def media(self, id): request, response, db = current.request, current.response, self.auth.db media = db.wiki_media(id) if media: if self.settings.manage_permissions: page = db.wiki_page(media.wiki_page) if not self.can_read(page): return self.not_authorized(page) request.args = [media.filename] m = response.download(request, db) current.session.forget() # get rid of the cookie response.headers['Last-Modified'] = \ request.utcnow.strftime("%a, %d %b %Y %H:%M:%S GMT") if 'Content-Disposition' in response.headers: del response.headers['Content-Disposition'] response.headers['Pragma'] = 'cache' response.headers['Cache-Control'] = 'private' return m else: raise HTTP(404) def menu(self, controller='default', function='index'): db = self.auth.db request = current.request menu_page = db.wiki_page(slug='wiki-menu') menu = [] if menu_page: tree = {'': menu} regex = re.compile('[\r\n\t]*(?P<base>(\s*\-\s*)+)(?P<title>\w.*?)\s+\>\s+(?P<link>\S+)') for match in regex.finditer(self.fix_hostname(menu_page.body)): base = match.group('base').replace(' ', '') title = match.group('title') link = match.group('link') title_page = None if link.startswith('@'): items = link[2:].split('/') if len(items) > 3: title_page = items[3] link = URL(a=items[0] or None, c=items[1] or controller, f=items[2] or function, args=items[3:]) parent = tree.get(base[1:], tree['']) subtree = [] tree[base] = subtree parent.append((current.T(title), request.args(0) == title_page, link, subtree)) if self.can_see_menu(): submenu = [] menu.append((current.T('[Wiki]'), None, None, submenu)) if URL() == URL(controller, function): if not str(request.args(0)).startswith('_'): slug = request.args(0) or 'index' mode = 1 elif request.args(0) == '_edit': slug = request.args(1) or 'index' mode = 2 elif request.args(0) == '_editmedia': slug = request.args(1) or 'index' mode = 3 else: mode = 0 if mode in (2, 3): submenu.append((current.T('View Page'), None, URL(controller, function, args=slug))) if mode in (1, 3): submenu.append((current.T('Edit Page'), None, URL(controller, function, args=('_edit', slug)))) if mode in (1, 2): submenu.append((current.T('Edit Page Media'), None, URL(controller, function, args=('_editmedia', slug)))) submenu.append((current.T('Create New Page'), None, URL(controller, function, args=('_create')))) # Moved next if to inside self.auth.user check if self.can_manage(): submenu.append((current.T('Manage Pages'), None, URL(controller, function, args=('_pages')))) submenu.append((current.T('Edit Menu'), None, URL(controller, function, args=('_edit', 'wiki-menu')))) # Also moved inside self.auth.user check submenu.append((current.T('Search Pages'), None, URL(controller, function, args=('_search')))) return menu def search(self, tags=None, query=None, cloud=True, preview=True, limitby=(0, 100), orderby=None): if not self.can_search(): return self.not_authorized() request = current.request content = CAT() if tags is None and query is None: form = FORM(INPUT(_name='q', requires=IS_NOT_EMPTY(), value=request.vars.q), INPUT(_type="submit", _value=current.T('Search')), _method='GET') content.append(DIV(form, _class='w2p_wiki_form')) if request.vars.q: tags = [v.strip() for v in request.vars.q.split(',')] tags = [v.lower() for v in tags if v] if tags or not query is None: db = self.auth.db count = db.wiki_tag.wiki_page.count() fields = [db.wiki_page.id, db.wiki_page.slug, db.wiki_page.title, db.wiki_page.tags, db.wiki_page.can_read] if preview: fields.append(db.wiki_page.body) if query is None: query = (db.wiki_page.id == db.wiki_tag.wiki_page) &\ (db.wiki_tag.name.belongs(tags)) query = query | db.wiki_page.title.contains(request.vars.q) if self.settings.restrict_search and not self.manage(): query = query & (db.wiki_page.created_by == self.auth.user_id) pages = db(query).select(count, *fields, **dict(orderby=orderby or ~count, groupby=reduce(lambda a, b: a | b, fields), distinct=True, limitby=limitby)) if request.extension in ('html', 'load'): if not pages: content.append(DIV(current.T("No results"), _class='w2p_wiki_form')) def link(t): return A(t, _href=URL(args='_search', vars=dict(q=t))) items = [DIV(H3(A(p.wiki_page.title, _href=URL( args=p.wiki_page.slug))), MARKMIN(self.first_paragraph(p.wiki_page)) if preview else '', DIV(_class='w2p_wiki_tags', *[link(t.strip()) for t in p.wiki_page.tags or [] if t.strip()]), _class='w2p_wiki_search_item') for p in pages] content.append(DIV(_class='w2p_wiki_pages', *items)) else: cloud = False content = [p.wiki_page.as_dict() for p in pages] elif cloud: content.append(self.cloud()['content']) if request.extension == 'load': return content return dict(content=content) def cloud(self): db = self.auth.db count = db.wiki_tag.wiki_page.count(distinct=True) ids = db(db.wiki_tag).select( db.wiki_tag.name, count, distinct=True, groupby=db.wiki_tag.name, orderby=~count, limitby=(0, 20)) if ids: a, b = ids[0](count), ids[-1](count) def style(c): STYLE = 'padding:0 0.2em;line-height:%.2fem;font-size:%.2fem' size = (1.5 * (c - b) / max(a - b, 1) + 1.3) return STYLE % (1.3, size) items = [] for item in ids: items.append(A(item.wiki_tag.name, _style=style(item(count)), _href=URL(args='_search', vars=dict(q=item.wiki_tag.name)))) items.append(' ') return dict(content=DIV(_class='w2p_cloud', *items)) def preview(self, render): request = current.request # FIXME: This is an ugly hack to ensure a default render # engine if not specified (with multiple render engines) if not "render" in request.post_vars: request.post_vars.render = None return render(request.post_vars) class Config(object): def __init__( self, filename, section, default_values={} ): self.config = ConfigParser.ConfigParser(default_values) self.config.read(filename) if not self.config.has_section(section): self.config.add_section(section) self.section = section self.filename = filename def read(self): if not(isinstance(current.session['settings_%s' % self.section], dict)): settings = dict(self.config.items(self.section)) else: settings = current.session['settings_%s' % self.section] return settings def save(self, options): for option, value in options: self.config.set(self.section, option, value) try: self.config.write(open(self.filename, 'w')) result = True except: current.session['settings_%s' % self.section] = dict(self.config.items(self.section)) result = False return result if __name__ == '__main__': import doctest doctest.testmod()
40.736364
178
0.531913
[ "BSD-3-Clause" ]
kvk3008/project
gluon/tools.py
250,936
Python
""" WSGI config for car_selling_parts project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/3.2/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'car_selling_parts.settings') application = get_wsgi_application()
24.176471
78
0.79562
[ "MIT" ]
vis7/car_parts_selling
car_selling_parts/wsgi.py
411
Python
''' UnrealCV ======== Provides functions to interact with games built using Unreal Engine. >>> import unrealcv >>> (HOST, PORT) = ('localhost', 9000) >>> client = unrealcv.Client((HOST, PORT)) ''' import sys, ctypes, struct, threading, socket, re, time, logging try: from Queue import Queue except: from queue import Queue # for Python 3 _L = logging.getLogger(__name__) # _L.addHandler(logging.NullHandler()) # Let client to decide how to do logging _L.handlers = [] h = logging.StreamHandler() h.setFormatter(logging.Formatter('%(levelname)s:%(module)s:%(lineno)d:%(message)s')) _L.addHandler(h) _L.propagate = False _L.setLevel(logging.INFO) fmt = 'I' class SocketMessage(object): ''' Define the format of a message. This class is defined similar to the class FNFSMessageHeader in UnrealEngine4, but without CRC check. The magic number is from Unreal implementation See https://github.com/EpicGames/UnrealEngine/blob/dff3c48be101bb9f84633a733ef79c91c38d9542/Engine/Source/Runtime/Sockets/Public/NetworkMessage.h ''' magic = ctypes.c_uint32(0x9E2B83C1).value def __init__(self, payload): self.magic = SocketMessage.magic self.payload_size = ctypes.c_uint32(len(payload)).value @classmethod def ReceivePayload(cls, socket): ''' Return only payload, not the raw message, None if failed. socket: a blocking socket for read data. ''' # rbufsize = -1 # From SocketServer.py rbufsize = 0 rfile = socket.makefile('rb', rbufsize) _L.debug('read raw_magic %s', threading.current_thread().name) try: raw_magic = rfile.read(4) # socket is disconnected or invalid except Exception as e: _L.debug('Fail to read raw_magic, %s', e) raw_magic = None _L.debug('read raw_magic %s done: %s', threading.current_thread().name, repr(raw_magic)) if not raw_magic: # nothing to read # _L.debug('socket disconnect') return None # print 'Receive raw magic: %d, %s' % (len(raw_magic), raw_magic) magic = struct.unpack(fmt, raw_magic)[0] # 'I' means unsigned int # print 'Receive magic:', magic if magic != cls.magic: _L.error('Error: receive a malformat message, the message should start from a four bytes uint32 magic number') return None # The next time it will read four bytes again _L.debug('read payload') raw_payload_size = rfile.read(4) # print 'Receive raw payload size: %d, %s' % (len(raw_payload_size), raw_payload_size) payload_size = struct.unpack('I', raw_payload_size)[0] _L.debug('Receive payload size %d', payload_size) # if the message is incomplete, should wait until all the data received payload = b"" remain_size = payload_size while remain_size > 0: data = rfile.read(remain_size) if not data: return None payload += data bytes_read = len(data) # len(data) is its string length, but we want length of bytes # print 'bytes_read %d, remain_size %d, read_str %s' % (bytes_read, remain_size, data) assert(bytes_read <= remain_size) remain_size -= bytes_read rfile.close() return payload @classmethod def WrapAndSendPayload(cls, socket, payload): ''' Send payload, true if success, false if failed ''' try: # From SocketServer.py # wbufsize = 0, flush immediately wbufsize = -1 # Convert socket_message = SocketMessage(payload) wfile = socket.makefile('wb', wbufsize) # Write the message wfile.write(struct.pack(fmt, socket_message.magic)) # Need to send the packed version # print 'Sent ', socket_message.magic wfile.write(struct.pack(fmt, socket_message.payload_size)) # print 'Sent ', socket_message.payload_size wfile.write(payload) # print 'Sent ', payload wfile.flush() wfile.close() # Close file object, not close the socket return True except Exception as e: _L.error('Fail to send message %s', e) return False class BaseClient(object): ''' BaseClient send message out and receiving message in a seperate thread. After calling the `send` function, only True or False will be returned to indicate whether the operation was successful. If you are trying to send a request and get a response, consider using `Client` instead. This class adds message framing on top of TCP ''' def __init__(self, endpoint, raw_message_handler): ''' Parameters: endpoint: a tuple (ip, port) message_handler: a function defined as `def message_handler(msg)` to handle incoming message, msg is a string ''' self.endpoint = endpoint self.raw_message_handler = raw_message_handler self.socket = None # if socket == None, means client is not connected self.wait_connected = threading.Event() # Start a thread to get data from the socket receiving_thread = threading.Thread(target = self.__receiving) receiving_thread.setDaemon(1) receiving_thread.start() def connect(self, timeout = 1): ''' Try to connect to server, return whether connection successful ''' if self.isconnected(): return True try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(self.endpoint) self.socket = s _L.debug('BaseClient: wait for connection confirm') self.wait_connected.clear() isset = self.wait_connected.wait(timeout) assert(isset != None) # in python prior to 2.7 wait will return None if isset: return True else: self.socket = None _L.error('Socket is created, but can not get connection confirm from %s, timeout after %.2f seconds', self.endpoint, timeout) return False # only assign self.socket to connected socket # so it is safe to use self.socket != None to check connection status # This does not neccessarily mean connection successful, might be closed by server # Unless explicitly to tell the server to accept new socket except Exception as e: _L.error('Can not connect to %s', str(self.endpoint)) _L.error("Error %s", e) self.socket = None return False def isconnected(self): return self.socket is not None def disconnect(self): if self.isconnected(): _L.debug("BaseClient, request disconnect from server in %s", threading.current_thread().name) self.socket.shutdown(socket.SHUT_RD) # Because socket is on read in __receiving thread, need to call shutdown to force it to close if self.socket: # This may also be set to None in the __receiving thread self.socket.close() self.socket = None time.sleep(0.1) # TODO, this is tricky def __receiving(self): ''' Receive packages, Extract message from packages Call self.message_handler if got a message Also check whether client is still connected ''' _L.debug('BaseClient start receiving in %s', threading.current_thread().name) while True: if self.isconnected(): # Only this thread is allowed to read from socket, otherwise need lock to avoid competing message = SocketMessage.ReceivePayload(self.socket) _L.debug('Got server raw message %s', message) if not message: _L.debug('BaseClient: remote disconnected, no more message') self.socket = None continue if message.startswith(b'connected'): _L.info('Got connection confirm: %s', repr(message)) self.wait_connected.set() # self.wait_connected.clear() continue if self.raw_message_handler: self.raw_message_handler(message) # will block this thread else: _L.error('No message handler for raw message %s', message) def send(self, message): ''' Send message out, return whether the message was successfully sent ''' if self.isconnected(): _L.debug('BaseClient: Send message %s', self.socket) SocketMessage.WrapAndSendPayload(self.socket, message) return True else: _L.error('Fail to send message, client is not connected') return False class Client(object): ''' Client can be used to send request to a game and get response Currently only one client is allowed at a time More clients will be rejected ''' def __raw_message_handler(self, raw_message): # print 'Waiting for message id %d' % self.message_id match = self.raw_message_regexp.match(raw_message) if match: [message_id, message_body] = (int(match.group(1)), match.group(2)) # TODO: handle multiline response message_body = raw_message[len(match.group(1))+1:] # Convert to utf-8 if it's not a byte array (as is the case for images) try: message_body = message_body.decode('utf-8') except UnicodeDecodeError: pass # print 'Received message id %s' % message_id if message_id == self.message_id: self.response = message_body self.wait_response.set() else: assert(False) else: if self.message_handler: def do_callback(): self.message_handler(raw_message) self.queue.put(do_callback) else: # Instead of just dropping this message, give a verbose notice _L.error('No message handler to handle message %s', raw_message) def __init__(self, endpoint, message_handler=None): self.raw_message_regexp = re.compile(b'(\d{1,8}):(.*)') self.message_client = BaseClient(endpoint, self.__raw_message_handler) self.message_handler = message_handler self.message_id = 0 self.wait_response = threading.Event() self.response = '' self.isconnected = self.message_client.isconnected self.connect = self.message_client.connect self.disconnect = self.message_client.disconnect self.queue = Queue() self.main_thread = threading.Thread(target = self.worker) self.main_thread.setDaemon(1) self.main_thread.start() def worker(self): while True: task = self.queue.get() task() self.queue.task_done() def request(self, message, timeout=5): # docstring in numpy style """ Send a request to server and wait util get a response from server or timeout. Parameters ---------- cmd : str command to control the game. More info can be seen from http://docs.unrealcv.org/en/master/reference/commands.html Returns ------- str plain text message from server Examples -------- >>> client = Client('localhost', 9000) >>> client.connect() >>> response = client.request('vget /camera/0/view') """ if sys.version_info[0] == 3: if not isinstance(message, bytes): message = message.encode("utf-8") def do_request(): raw_message = b'%d:%s' % (self.message_id, message) _L.debug('Request: %s', raw_message.decode("utf-8")) if not self.message_client.send(raw_message): return None # request can only be sent in the main thread, do not support multi-thread submitting request together if threading.current_thread().name == self.main_thread.name: do_request() else: self.queue.put(do_request) # Timeout is required # see: https://bugs.python.org/issue8844 self.wait_response.clear() # This is important isset = self.wait_response.wait(timeout) self.message_id += 1 # Increment it only after the request/response cycle finished assert(isset != None) # only python prior to 2.7 will return None if isset: return self.response else: _L.error('Can not receive a response from server, timeout after %.2f seconds', timeout) return None (HOST, PORT) = ('localhost', 9000) client = Client((HOST, PORT), None)
38.478006
149
0.604146
[ "MIT" ]
AI-cecream/unrealcv
client/python/unrealcv/__init__.py
13,121
Python