fumiyau/python_no_comments_test10000 · Datasets at Hugging Face

f71304694bf0a8c50772bd6404f430c84c395310

14,235

py

Python

sdk/python/pulumi_azure/containerservice/kubernetes_cluster_node_pool.py

pulumi-bot/pulumi-azure

64d5c30a77b3f4de117068add359ef85293cef8e

[ "ECL-2.0", "Apache-2.0" ]

null

sdk/python/pulumi_azure/containerservice/kubernetes_cluster_node_pool.py

pulumi-bot/pulumi-azure

64d5c30a77b3f4de117068add359ef85293cef8e

[ "ECL-2.0", "Apache-2.0" ]

null

sdk/python/pulumi_azure/containerservice/kubernetes_cluster_node_pool.py

pulumi-bot/pulumi-azure

64d5c30a77b3f4de117068add359ef85293cef8e

[ "ECL-2.0", "Apache-2.0" ]

null

# coding=utf-8 # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** # *** Do not edit by hand unless you're certain you know what you are doing! *** import json import warnings import pulumi import pulumi.runtime from typing import Union from .. import utilities, tables class KubernetesClusterNodePool(pulumi.CustomResource): availability_zones: pulumi.Output[list] """ A list of Availability Zones where the Nodes in this Node Pool should be created in. """ enable_auto_scaling: pulumi.Output[bool] """ Whether to enable [auto-scaler](https://docs.microsoft.com/en-us/azure/aks/cluster-autoscaler). Defaults to `false`. """ enable_node_public_ip: pulumi.Output[bool] """ Should each node have a Public IP Address? Defaults to `false`. """ kubernetes_cluster_id: pulumi.Output[str] """ The ID of the Kubernetes Cluster where this Node Pool should exist. Changing this forces a new resource to be created. """ max_count: pulumi.Output[float] """ The maximum number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be greater than or equal to `min_count`. """ max_pods: pulumi.Output[float] """ The maximum number of pods that can run on each agent. Changing this forces a new resource to be created. """ min_count: pulumi.Output[float] """ The minimum number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be less than or equal to `max_count`. """ name: pulumi.Output[str] """ The name of the Node Pool which should be created within the Kubernetes Cluster. Changing this forces a new resource to be created. """ node_count: pulumi.Output[float] """ The initial number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be a value in the range `min_count` - `max_count`. """ node_labels: pulumi.Output[dict] """ A map of Kubernetes labels which should be applied to nodes in this Node Pool. """ node_taints: pulumi.Output[list] """ A list of Kubernetes taints which should be applied to nodes in the agent pool (e.g `key=value:NoSchedule`). """ os_disk_size_gb: pulumi.Output[float] """ The Agent Operating System disk size in GB. Changing this forces a new resource to be created. """ os_type: pulumi.Output[str] """ The Operating System which should be used for this Node Pool. Changing this forces a new resource to be created. Possible values are `Linux` and `Windows`. Defaults to `Linux`. """ tags: pulumi.Output[dict] """ A mapping of tags to assign to the resource. """ vm_size: pulumi.Output[str] """ The SKU which should be used for the Virtual Machines used in this Node Pool. Changing this forces a new resource to be created. """ vnet_subnet_id: pulumi.Output[str] """ The ID of the Subnet where this Node Pool should exist. """ def __init__(__self__, resource_name, opts=None, availability_zones=None, enable_auto_scaling=None, enable_node_public_ip=None, kubernetes_cluster_id=None, max_count=None, max_pods=None, min_count=None, name=None, node_count=None, node_labels=None, node_taints=None, os_disk_size_gb=None, os_type=None, tags=None, vm_size=None, vnet_subnet_id=None, __props__=None, __name__=None, __opts__=None): """ Manages a Node Pool within a Kubernetes Cluster > **NOTE:** Multiple Node Pools are only supported when the Kubernetes Cluster is using Virtual Machine Scale Sets. ## Example Usage ```python import pulumi import pulumi_azure as azure example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe") example_kubernetes_cluster = azure.containerservice.KubernetesCluster("exampleKubernetesCluster", location=example_resource_group.location, resource_group_name=example_resource_group.name, dns_prefix="exampleaks1", default_node_pool={ "name": "default", "node_count": 1, "vm_size": "Standard_D2_v2", }, service_principal={ "client_id": "00000000-0000-0000-0000-000000000000", "client_secret": "00000000000000000000000000000000", }) example_kubernetes_cluster_node_pool = azure.containerservice.KubernetesClusterNodePool("exampleKubernetesClusterNodePool", kubernetes_cluster_id=example_kubernetes_cluster.id, vm_size="Standard_DS2_v2", node_count=1, tags={ "Environment": "Production", }) ``` :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[list] availability_zones: A list of Availability Zones where the Nodes in this Node Pool should be created in. :param pulumi.Input[bool] enable_auto_scaling: Whether to enable [auto-scaler](https://docs.microsoft.com/en-us/azure/aks/cluster-autoscaler). Defaults to `false`. :param pulumi.Input[bool] enable_node_public_ip: Should each node have a Public IP Address? Defaults to `false`. :param pulumi.Input[str] kubernetes_cluster_id: The ID of the Kubernetes Cluster where this Node Pool should exist. Changing this forces a new resource to be created. :param pulumi.Input[float] max_count: The maximum number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be greater than or equal to `min_count`. :param pulumi.Input[float] max_pods: The maximum number of pods that can run on each agent. Changing this forces a new resource to be created. :param pulumi.Input[float] min_count: The minimum number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be less than or equal to `max_count`. :param pulumi.Input[str] name: The name of the Node Pool which should be created within the Kubernetes Cluster. Changing this forces a new resource to be created. :param pulumi.Input[float] node_count: The initial number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be a value in the range `min_count` - `max_count`. :param pulumi.Input[dict] node_labels: A map of Kubernetes labels which should be applied to nodes in this Node Pool. :param pulumi.Input[list] node_taints: A list of Kubernetes taints which should be applied to nodes in the agent pool (e.g `key=value:NoSchedule`). :param pulumi.Input[float] os_disk_size_gb: The Agent Operating System disk size in GB. Changing this forces a new resource to be created. :param pulumi.Input[str] os_type: The Operating System which should be used for this Node Pool. Changing this forces a new resource to be created. Possible values are `Linux` and `Windows`. Defaults to `Linux`. :param pulumi.Input[dict] tags: A mapping of tags to assign to the resource. :param pulumi.Input[str] vm_size: The SKU which should be used for the Virtual Machines used in this Node Pool. Changing this forces a new resource to be created. :param pulumi.Input[str] vnet_subnet_id: The ID of the Subnet where this Node Pool should exist. """ if __name__ is not None: warnings.warn("explicit use of __name__ is deprecated", DeprecationWarning) resource_name = __name__ if __opts__ is not None: warnings.warn("explicit use of __opts__ is deprecated, use 'opts' instead", DeprecationWarning) opts = __opts__ 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__ = dict() __props__['availability_zones'] = availability_zones __props__['enable_auto_scaling'] = enable_auto_scaling __props__['enable_node_public_ip'] = enable_node_public_ip if kubernetes_cluster_id is None: raise TypeError("Missing required property 'kubernetes_cluster_id'") __props__['kubernetes_cluster_id'] = kubernetes_cluster_id __props__['max_count'] = max_count __props__['max_pods'] = max_pods __props__['min_count'] = min_count __props__['name'] = name __props__['node_count'] = node_count __props__['node_labels'] = node_labels __props__['node_taints'] = node_taints __props__['os_disk_size_gb'] = os_disk_size_gb __props__['os_type'] = os_type __props__['tags'] = tags if vm_size is None: raise TypeError("Missing required property 'vm_size'") __props__['vm_size'] = vm_size __props__['vnet_subnet_id'] = vnet_subnet_id super(KubernetesClusterNodePool, __self__).__init__( 'azure:containerservice/kubernetesClusterNodePool:KubernetesClusterNodePool', resource_name, __props__, opts) @staticmethod def get(resource_name, id, opts=None, availability_zones=None, enable_auto_scaling=None, enable_node_public_ip=None, kubernetes_cluster_id=None, max_count=None, max_pods=None, min_count=None, name=None, node_count=None, node_labels=None, node_taints=None, os_disk_size_gb=None, os_type=None, tags=None, vm_size=None, vnet_subnet_id=None): """ Get an existing KubernetesClusterNodePool 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 str id: The unique provider ID of the resource to lookup. :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[list] availability_zones: A list of Availability Zones where the Nodes in this Node Pool should be created in. :param pulumi.Input[bool] enable_auto_scaling: Whether to enable [auto-scaler](https://docs.microsoft.com/en-us/azure/aks/cluster-autoscaler). Defaults to `false`. :param pulumi.Input[bool] enable_node_public_ip: Should each node have a Public IP Address? Defaults to `false`. :param pulumi.Input[str] kubernetes_cluster_id: The ID of the Kubernetes Cluster where this Node Pool should exist. Changing this forces a new resource to be created. :param pulumi.Input[float] max_count: The maximum number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be greater than or equal to `min_count`. :param pulumi.Input[float] max_pods: The maximum number of pods that can run on each agent. Changing this forces a new resource to be created. :param pulumi.Input[float] min_count: The minimum number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be less than or equal to `max_count`. :param pulumi.Input[str] name: The name of the Node Pool which should be created within the Kubernetes Cluster. Changing this forces a new resource to be created. :param pulumi.Input[float] node_count: The initial number of nodes which should exist within this Node Pool. Valid values are between `1` and `100` and must be a value in the range `min_count` - `max_count`. :param pulumi.Input[dict] node_labels: A map of Kubernetes labels which should be applied to nodes in this Node Pool. :param pulumi.Input[list] node_taints: A list of Kubernetes taints which should be applied to nodes in the agent pool (e.g `key=value:NoSchedule`). :param pulumi.Input[float] os_disk_size_gb: The Agent Operating System disk size in GB. Changing this forces a new resource to be created. :param pulumi.Input[str] os_type: The Operating System which should be used for this Node Pool. Changing this forces a new resource to be created. Possible values are `Linux` and `Windows`. Defaults to `Linux`. :param pulumi.Input[dict] tags: A mapping of tags to assign to the resource. :param pulumi.Input[str] vm_size: The SKU which should be used for the Virtual Machines used in this Node Pool. Changing this forces a new resource to be created. :param pulumi.Input[str] vnet_subnet_id: The ID of the Subnet where this Node Pool should exist. """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) __props__ = dict() __props__["availability_zones"] = availability_zones __props__["enable_auto_scaling"] = enable_auto_scaling __props__["enable_node_public_ip"] = enable_node_public_ip __props__["kubernetes_cluster_id"] = kubernetes_cluster_id __props__["max_count"] = max_count __props__["max_pods"] = max_pods __props__["min_count"] = min_count __props__["name"] = name __props__["node_count"] = node_count __props__["node_labels"] = node_labels __props__["node_taints"] = node_taints __props__["os_disk_size_gb"] = os_disk_size_gb __props__["os_type"] = os_type __props__["tags"] = tags __props__["vm_size"] = vm_size __props__["vnet_subnet_id"] = vnet_subnet_id return KubernetesClusterNodePool(resource_name, opts=opts, __props__=__props__) def translate_output_property(self, prop): return tables._CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop def translate_input_property(self, prop): return tables._SNAKE_TO_CAMEL_CASE_TABLE.get(prop) or prop

61.891304

399

0.70144

import json import warnings import pulumi import pulumi.runtime from typing import Union from .. import utilities, tables class KubernetesClusterNodePool(pulumi.CustomResource): availability_zones: pulumi.Output[list] enable_auto_scaling: pulumi.Output[bool] enable_node_public_ip: pulumi.Output[bool] kubernetes_cluster_id: pulumi.Output[str] max_count: pulumi.Output[float] max_pods: pulumi.Output[float] min_count: pulumi.Output[float] name: pulumi.Output[str] node_count: pulumi.Output[float] node_labels: pulumi.Output[dict] node_taints: pulumi.Output[list] os_disk_size_gb: pulumi.Output[float] os_type: pulumi.Output[str] tags: pulumi.Output[dict] vm_size: pulumi.Output[str] vnet_subnet_id: pulumi.Output[str] def __init__(__self__, resource_name, opts=None, availability_zones=None, enable_auto_scaling=None, enable_node_public_ip=None, kubernetes_cluster_id=None, max_count=None, max_pods=None, min_count=None, name=None, node_count=None, node_labels=None, node_taints=None, os_disk_size_gb=None, os_type=None, tags=None, vm_size=None, vnet_subnet_id=None, __props__=None, __name__=None, __opts__=None): if __name__ is not None: warnings.warn("explicit use of __name__ is deprecated", DeprecationWarning) resource_name = __name__ if __opts__ is not None: warnings.warn("explicit use of __opts__ is deprecated, use 'opts' instead", DeprecationWarning) opts = __opts__ 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__ = dict() __props__['availability_zones'] = availability_zones __props__['enable_auto_scaling'] = enable_auto_scaling __props__['enable_node_public_ip'] = enable_node_public_ip if kubernetes_cluster_id is None: raise TypeError("Missing required property 'kubernetes_cluster_id'") __props__['kubernetes_cluster_id'] = kubernetes_cluster_id __props__['max_count'] = max_count __props__['max_pods'] = max_pods __props__['min_count'] = min_count __props__['name'] = name __props__['node_count'] = node_count __props__['node_labels'] = node_labels __props__['node_taints'] = node_taints __props__['os_disk_size_gb'] = os_disk_size_gb __props__['os_type'] = os_type __props__['tags'] = tags if vm_size is None: raise TypeError("Missing required property 'vm_size'") __props__['vm_size'] = vm_size __props__['vnet_subnet_id'] = vnet_subnet_id super(KubernetesClusterNodePool, __self__).__init__( 'azure:containerservice/kubernetesClusterNodePool:KubernetesClusterNodePool', resource_name, __props__, opts) @staticmethod def get(resource_name, id, opts=None, availability_zones=None, enable_auto_scaling=None, enable_node_public_ip=None, kubernetes_cluster_id=None, max_count=None, max_pods=None, min_count=None, name=None, node_count=None, node_labels=None, node_taints=None, os_disk_size_gb=None, os_type=None, tags=None, vm_size=None, vnet_subnet_id=None): opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) __props__ = dict() __props__["availability_zones"] = availability_zones __props__["enable_auto_scaling"] = enable_auto_scaling __props__["enable_node_public_ip"] = enable_node_public_ip __props__["kubernetes_cluster_id"] = kubernetes_cluster_id __props__["max_count"] = max_count __props__["max_pods"] = max_pods __props__["min_count"] = min_count __props__["name"] = name __props__["node_count"] = node_count __props__["node_labels"] = node_labels __props__["node_taints"] = node_taints __props__["os_disk_size_gb"] = os_disk_size_gb __props__["os_type"] = os_type __props__["tags"] = tags __props__["vm_size"] = vm_size __props__["vnet_subnet_id"] = vnet_subnet_id return KubernetesClusterNodePool(resource_name, opts=opts, __props__=__props__) def translate_output_property(self, prop): return tables._CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop def translate_input_property(self, prop): return tables._SNAKE_TO_CAMEL_CASE_TABLE.get(prop) or prop

true

f71304e38931d2ddc525dcc080573bd1623348ca

2,137

py

Python

conans/test/util/detect_test.py

ytimenkov/conan

89eb275b9696b308aaaa1fbfaa0f8cdab284a764

[ "MIT" ]

null

conans/test/util/detect_test.py

ytimenkov/conan

89eb275b9696b308aaaa1fbfaa0f8cdab284a764

[ "MIT" ]

null

conans/test/util/detect_test.py

ytimenkov/conan

89eb275b9696b308aaaa1fbfaa0f8cdab284a764

[ "MIT" ]

null

import platform import subprocess import unittest from conans import tools from conans.client.conf.detect import detect_defaults_settings from conans.test.utils.tools import TestBufferConanOutput class DetectTest(unittest.TestCase): def detect_default_compilers_test(self): platform_default_compilers = { "Linux": "gcc", "Darwin": "apple-clang", "Windows": "Visual Studio" } output = TestBufferConanOutput() result = detect_defaults_settings(output) # result is a list of tuples (name, value) so converting it to dict result = dict(result) platform_compiler = platform_default_compilers.get(platform.system(), None) if platform_compiler is not None: self.assertEquals(result.get("compiler", None), platform_compiler) def detect_default_in_mac_os_using_gcc_as_default_test(self): """ Test if gcc in Mac OS X is using apple-clang as frontend """ # See: https://github.com/conan-io/conan/issues/2231 if platform.system() != "Darwin": return try: output = subprocess.check_output(["gcc", "--version"], stderr=subprocess.STDOUT) except subprocess.CalledProcessError: # gcc is not installed or there is any error (no test scenario) return if b"clang" not in output: # Not test scenario gcc should display clang in output # see: https://stackoverflow.com/questions/19535422/os-x-10-9-gcc-links-to-clang raise Exception("Apple gcc doesn't point to clang with gcc frontend anymore! please check") output = TestBufferConanOutput() with tools.environment_append({"CC": "gcc"}): result = detect_defaults_settings(output) # result is a list of tuples (name, value) so converting it to dict result = dict(result) # No compiler should be detected self.assertIsNone(result.get("compiler", None)) self.assertIn("gcc detected as a frontend using apple-clang", output) self.assertIsNotNone(output.error)

39.574074

103

0.659336

import platform import subprocess import unittest from conans import tools from conans.client.conf.detect import detect_defaults_settings from conans.test.utils.tools import TestBufferConanOutput class DetectTest(unittest.TestCase): def detect_default_compilers_test(self): platform_default_compilers = { "Linux": "gcc", "Darwin": "apple-clang", "Windows": "Visual Studio" } output = TestBufferConanOutput() result = detect_defaults_settings(output) result = dict(result) platform_compiler = platform_default_compilers.get(platform.system(), None) if platform_compiler is not None: self.assertEquals(result.get("compiler", None), platform_compiler) def detect_default_in_mac_os_using_gcc_as_default_test(self): if platform.system() != "Darwin": return try: output = subprocess.check_output(["gcc", "--version"], stderr=subprocess.STDOUT) except subprocess.CalledProcessError: return if b"clang" not in output: raise Exception("Apple gcc doesn't point to clang with gcc frontend anymore! please check") output = TestBufferConanOutput() with tools.environment_append({"CC": "gcc"}): result = detect_defaults_settings(output) # result is a list of tuples (name, value) so converting it to dict result = dict(result) # No compiler should be detected self.assertIsNone(result.get("compiler", None)) self.assertIn("gcc detected as a frontend using apple-clang", output) self.assertIsNotNone(output.error)

true

f7130518f2b9fedcf4b6b2640fe15a1a4a845769

5,898

py

Python

src/fonduer_utils.py

kaikun213/fonduer-troy200

d5653df48e3ce3037f4f1b500d454947ad0d010c

[ "MIT" ]

null

src/fonduer_utils.py

kaikun213/fonduer-troy200

d5653df48e3ce3037f4f1b500d454947ad0d010c

[ "MIT" ]

null

src/fonduer_utils.py

kaikun213/fonduer-troy200

d5653df48e3ce3037f4f1b500d454947ad0d010c

[ "MIT" ]

null

import emmental import numpy as np from fonduer import Meta from emmental.modules.embedding_module import EmbeddingModule from emmental.data import EmmentalDataLoader from emmental.model import EmmentalModel from emmental.learner import EmmentalLearner from fonduer.learning.utils import collect_word_counter from fonduer.learning.dataset import FonduerDataset from fonduer.learning.task import create_task from troy200_utils import entity_level_f1 ABSTAIN = -1 FALSE = 0 TRUE = 1 def get_methods(ATTRIBUTE, gold, gold_file, all_docs): train_docs = all_docs[0] dev_docs = all_docs[1] test_docs = all_docs[2] def train_model(cands, F, align_type, model_type="LogisticRegression"): # Extract candidates and features based on the align type (row/column) align_val = 0 if align_type == "row" else 1 train_cands = cands[align_val][0] F_train = F[align_val][0] train_marginals = np.array([[0,1] if gold[align_val](x) else [1,0] for x in train_cands[0]]) # 1.) Setup training config config = { "meta_config": {"verbose": True}, "model_config": {"model_path": None, "device": 0, "dataparallel": False}, "learner_config": { "n_epochs": 50, "optimizer_config": {"lr": 0.001, "l2": 0.0}, "task_scheduler": "round_robin", }, "logging_config": { "evaluation_freq": 1, "counter_unit": "epoch", "checkpointing": False, "checkpointer_config": { "checkpoint_metric": {f"{ATTRIBUTE}/{ATTRIBUTE}/train/loss": "min"}, "checkpoint_freq": 1, "checkpoint_runway": 2, "clear_intermediate_checkpoints": True, "clear_all_checkpoints": True, }, }, } emmental.init(Meta.log_path) emmental.Meta.update_config(config=config) # 2.) Collect word counter from training data word_counter = collect_word_counter(train_cands) # 3.) Generate word embedding module for LSTM model # (in Logistic Regression, we generate it since Fonduer dataset requires word2id dict) # Geneate special tokens arity = 2 specials = [] for i in range(arity): specials += [f"~~[[{i}", f"{i}]]~~"] emb_layer = EmbeddingModule( word_counter=word_counter, word_dim=300, specials=specials ) # 4.) Generate dataloader for training set # No noise in Gold labels train_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, train_cands[0], F_train[0], emb_layer.word2id, train_marginals, ), split="train", batch_size=100, shuffle=True, ) # 5.) Training tasks = create_task( ATTRIBUTE, 2, F_train[0].shape[1], 2, emb_layer, model=model_type # "LSTM" ) model = EmmentalModel(name=f"{ATTRIBUTE}_task") for task in tasks: model.add_task(task) emmental_learner = EmmentalLearner() emmental_learner.learn(model, [train_dataloader]) return (model, emb_layer) def eval_model(model, emb_layer, cands, F, align_type = "row"): # Extract candidates and features based on the align type (row/column) align_val = 0 if align_type == "row" else 1 train_cands = cands[align_val][0] dev_cands = cands[align_val][1] test_cands = cands[align_val][2] F_train = F[align_val][0] F_dev = F[align_val][1] F_test = F[align_val][2] row_on = True if align_type == "row" else False col_on = True if align_type == "col" else False # Generate dataloader for test data test_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, test_cands[0], F_test[0], emb_layer.word2id, 2 ), split="test", batch_size=100, shuffle=False, ) test_preds = model.predict(test_dataloader, return_preds=True) positive = np.where(np.array(test_preds["probs"][ATTRIBUTE])[:, TRUE] > 0.6) true_pred = [test_cands[0][_] for _ in positive[0]] test_results = entity_level_f1(true_pred, gold_file, ATTRIBUTE, test_docs, row_on=row_on, col_on=col_on) # Run on dev and train set for validation # We run the predictions also on our training and dev set, to validate that everything seems to work smoothly # Generate dataloader for dev data dev_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, dev_cands[0], F_dev[0], emb_layer.word2id, 2 ), split="test", batch_size=100, shuffle=False, ) dev_preds = model.predict(dev_dataloader, return_preds=True) positive_dev = np.where(np.array(dev_preds["probs"][ATTRIBUTE])[:, TRUE] > 0.6) true_dev_pred = [dev_cands[0][_] for _ in positive_dev[0]] dev_results = entity_level_f1(true_dev_pred, gold_file, ATTRIBUTE, dev_docs, row_on=row_on, col_on=col_on) # Generate dataloader for train data train_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, train_cands[0], F_train[0], emb_layer.word2id, 2 ), split="test", batch_size=100, shuffle=False, ) train_preds = model.predict(train_dataloader, return_preds=True) positive_train = np.where(np.array(train_preds["probs"][ATTRIBUTE])[:, TRUE] > 0.6) true_train_pred = [train_cands[0][_] for _ in positive_train[0]] train_results = entity_level_f1(true_train_pred, gold_file, ATTRIBUTE, train_docs, row_on=row_on, col_on=col_on) return [train_results, dev_results, test_results] return (train_model, eval_model)

34.694118

116

0.651577

import emmental import numpy as np from fonduer import Meta from emmental.modules.embedding_module import EmbeddingModule from emmental.data import EmmentalDataLoader from emmental.model import EmmentalModel from emmental.learner import EmmentalLearner from fonduer.learning.utils import collect_word_counter from fonduer.learning.dataset import FonduerDataset from fonduer.learning.task import create_task from troy200_utils import entity_level_f1 ABSTAIN = -1 FALSE = 0 TRUE = 1 def get_methods(ATTRIBUTE, gold, gold_file, all_docs): train_docs = all_docs[0] dev_docs = all_docs[1] test_docs = all_docs[2] def train_model(cands, F, align_type, model_type="LogisticRegression"): align_val = 0 if align_type == "row" else 1 train_cands = cands[align_val][0] F_train = F[align_val][0] train_marginals = np.array([[0,1] if gold[align_val](x) else [1,0] for x in train_cands[0]]) config = { "meta_config": {"verbose": True}, "model_config": {"model_path": None, "device": 0, "dataparallel": False}, "learner_config": { "n_epochs": 50, "optimizer_config": {"lr": 0.001, "l2": 0.0}, "task_scheduler": "round_robin", }, "logging_config": { "evaluation_freq": 1, "counter_unit": "epoch", "checkpointing": False, "checkpointer_config": { "checkpoint_metric": {f"{ATTRIBUTE}/{ATTRIBUTE}/train/loss": "min"}, "checkpoint_freq": 1, "checkpoint_runway": 2, "clear_intermediate_checkpoints": True, "clear_all_checkpoints": True, }, }, } emmental.init(Meta.log_path) emmental.Meta.update_config(config=config) word_counter = collect_word_counter(train_cands) arity = 2 specials = [] for i in range(arity): specials += [f"~~[[{i}", f"{i}]]~~"] emb_layer = EmbeddingModule( word_counter=word_counter, word_dim=300, specials=specials ) train_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, train_cands[0], F_train[0], emb_layer.word2id, train_marginals, ), split="train", batch_size=100, shuffle=True, ) tasks = create_task( ATTRIBUTE, 2, F_train[0].shape[1], 2, emb_layer, model=model_type ) model = EmmentalModel(name=f"{ATTRIBUTE}_task") for task in tasks: model.add_task(task) emmental_learner = EmmentalLearner() emmental_learner.learn(model, [train_dataloader]) return (model, emb_layer) def eval_model(model, emb_layer, cands, F, align_type = "row"): align_val = 0 if align_type == "row" else 1 train_cands = cands[align_val][0] dev_cands = cands[align_val][1] test_cands = cands[align_val][2] F_train = F[align_val][0] F_dev = F[align_val][1] F_test = F[align_val][2] row_on = True if align_type == "row" else False col_on = True if align_type == "col" else False test_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, test_cands[0], F_test[0], emb_layer.word2id, 2 ), split="test", batch_size=100, shuffle=False, ) test_preds = model.predict(test_dataloader, return_preds=True) positive = np.where(np.array(test_preds["probs"][ATTRIBUTE])[:, TRUE] > 0.6) true_pred = [test_cands[0][_] for _ in positive[0]] test_results = entity_level_f1(true_pred, gold_file, ATTRIBUTE, test_docs, row_on=row_on, col_on=col_on) dev_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, dev_cands[0], F_dev[0], emb_layer.word2id, 2 ), split="test", batch_size=100, shuffle=False, ) dev_preds = model.predict(dev_dataloader, return_preds=True) positive_dev = np.where(np.array(dev_preds["probs"][ATTRIBUTE])[:, TRUE] > 0.6) true_dev_pred = [dev_cands[0][_] for _ in positive_dev[0]] dev_results = entity_level_f1(true_dev_pred, gold_file, ATTRIBUTE, dev_docs, row_on=row_on, col_on=col_on) train_dataloader = EmmentalDataLoader( task_to_label_dict={ATTRIBUTE: "labels"}, dataset=FonduerDataset( ATTRIBUTE, train_cands[0], F_train[0], emb_layer.word2id, 2 ), split="test", batch_size=100, shuffle=False, ) train_preds = model.predict(train_dataloader, return_preds=True) positive_train = np.where(np.array(train_preds["probs"][ATTRIBUTE])[:, TRUE] > 0.6) true_train_pred = [train_cands[0][_] for _ in positive_train[0]] train_results = entity_level_f1(true_train_pred, gold_file, ATTRIBUTE, train_docs, row_on=row_on, col_on=col_on) return [train_results, dev_results, test_results] return (train_model, eval_model)

true

f71305b2f41d57068e7b72cf7780ca0349393aab

1,949

py

Python

contrib/performance/sqlusage/requests/propfind_invite.py

backwardn/ccs-calendarserver

13c706b985fb728b9aab42dc0fef85aae21921c3

[ "Apache-2.0" ]

462

2016-08-14T17:43:24.000Z

2022-03-17T07:38:16.000Z

contrib/performance/sqlusage/requests/propfind_invite.py

backwardn/ccs-calendarserver

13c706b985fb728b9aab42dc0fef85aae21921c3

[ "Apache-2.0" ]

72

2016-09-01T23:19:35.000Z

2020-02-05T02:09:26.000Z

contrib/performance/sqlusage/requests/propfind_invite.py

backwardn/ccs-calendarserver

13c706b985fb728b9aab42dc0fef85aae21921c3

[ "Apache-2.0" ]

171

2016-08-16T03:50:30.000Z

2022-03-26T11:49:55.000Z

## # Copyright (c) 2012-2017 Apple Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ## from caldavclientlibrary.protocol.http.data.string import ResponseDataString from caldavclientlibrary.protocol.webdav.definitions import statuscodes, \ headers from caldavclientlibrary.protocol.webdav.propfind import PropFind from contrib.performance.sqlusage.requests.httpTests import HTTPTestBase from caldavclientlibrary.protocol.caldav.definitions import csxml class PropfindInviteTest(HTTPTestBase): """ A propfind operation """ def __init__(self, label, sessions, logFilePath, logFilePrefix, depth=1): super(PropfindInviteTest, self).__init__(label, sessions, logFilePath, logFilePrefix) self.depth = headers.Depth1 if depth == 1 else headers.Depth0 def doRequest(self): """ Execute the actual HTTP request. """ props = ( csxml.invite, ) # Create WebDAV propfind request = PropFind(self.sessions[0], self.sessions[0].calendarHref, self.depth, props) result = ResponseDataString() request.setOutput(result) # Process it self.sessions[0].runSession(request) # If its a 207 we want to parse the XML if request.getStatusCode() == statuscodes.MultiStatus: pass else: raise RuntimeError("Propfind request failed: %s" % (request.getStatusCode(),))

35.436364

94

0.709595

from caldavclientlibrary.protocol.http.data.string import ResponseDataString from caldavclientlibrary.protocol.webdav.definitions import statuscodes, \ headers from caldavclientlibrary.protocol.webdav.propfind import PropFind from contrib.performance.sqlusage.requests.httpTests import HTTPTestBase from caldavclientlibrary.protocol.caldav.definitions import csxml class PropfindInviteTest(HTTPTestBase): def __init__(self, label, sessions, logFilePath, logFilePrefix, depth=1): super(PropfindInviteTest, self).__init__(label, sessions, logFilePath, logFilePrefix) self.depth = headers.Depth1 if depth == 1 else headers.Depth0 def doRequest(self): props = ( csxml.invite, ) request = PropFind(self.sessions[0], self.sessions[0].calendarHref, self.depth, props) result = ResponseDataString() request.setOutput(result) self.sessions[0].runSession(request) if request.getStatusCode() == statuscodes.MultiStatus: pass else: raise RuntimeError("Propfind request failed: %s" % (request.getStatusCode(),))

true

f713067ddbfe4dba691898fb82829f79228edd1c

11,238

py

Python

src/plivo/rest/freeswitch/cacheserver.py

mknecht/plivoframework

29fc41fb3c887d5d9022a941e87bbeb2269112ff

[ "Condor-1.1" ]

151

2015-01-14T13:35:47.000Z

2022-01-25T02:47:14.000Z

src/plivo/rest/freeswitch/cacheserver.py

altanai/plivoframework

d8d182c7af17c3fbe514d7dfd68d0608ce798f47

[ "Condor-1.1" ]

14

2015-01-02T05:12:04.000Z

2021-02-03T04:25:39.000Z

src/plivo/rest/freeswitch/cacheserver.py

altanai/plivoframework

d8d182c7af17c3fbe514d7dfd68d0608ce798f47

[ "Condor-1.1" ]

107

2015-01-02T04:15:28.000Z

2022-02-07T18:14:18.000Z

# -*- coding: utf-8 -*- # Copyright (c) 2011 Plivo Team. See LICENSE for details from gevent import monkey monkey.patch_all() import grp import os import pwd import signal import sys import optparse from flask import Flask import gevent from gevent.wsgi import WSGIServer from gevent.pywsgi import WSGIServer as PyWSGIServer from plivo.rest.freeswitch.cacheapi import PlivoCacheApi import plivo.utils.daemonize from plivo.rest.freeswitch import cacheurls, helpers, cacheapi from plivo.utils.logger import StdoutLogger, FileLogger, SysLogger, DummyLogger, HTTPLogger class PlivoCacheServer(PlivoCacheApi): """Class PlivoCacheServer""" name = 'PlivoCacheServer' def __init__(self, configfile, daemon=False, pidfile='/tmp/plivo_cache.pid'): self._daemon = daemon self._run = False self._pidfile = pidfile self.configfile = configfile self._wsgi_mode = WSGIServer # create flask app self.app = Flask(self.name) # load config self.cache = None self._config = None self.load_config() # expose API functions to flask app for path, func_desc in cacheurls.URLS.iteritems(): func, methods = func_desc fn = getattr(self, func.__name__) self.app.add_url_rule(path, func.__name__, fn, methods=methods) self.log.info("Listening HTTP") self.log.info("%s mode set" % str(self._wsgi_mode)) self.http_server = self._wsgi_mode((self.http_host, self.http_port), self.app, log=self.log) def create_cache(self, config): # load cache params self.redis_host = config.get('cache_server', 'REDIS_HOST', default='') self.redis_port = config.get('cache_server', 'REDIS_PORT', default='') self.redis_db = config.get('cache_server', 'REDIS_DB', default='') self.redis_pw = config.get('cache_server', 'REDIS_PASSWORD', default=None) self.proxy_url = config.get('cache_server', 'PROXY_URL', default=None) self.http_timeout = int(config.get('cache_server', 'HTTP_TIMEOUT', default=60)) if self.redis_host and self.redis_port and self.redis_db: self.cache = cacheapi.ResourceCache(self.redis_host, int(self.redis_port), int(self.redis_db), self.redis_pw, self.proxy_url, self.http_timeout) return True self.log.error("Cannot run cache server, cache not set !") raise Exception("Cannot run cache server, cache not set !") def get_log(self): return self.log def get_config(self): return self._config def get_cache(self): return self.cache def create_logger(self, config): """This will create a logger using helpers.PlivoConfig instance Based on the settings in the configuration file, LOG_TYPE will determine if we will log in file, syslog, stdout, http or dummy (no log) """ if self._daemon is False: logtype = config.get('cache_server', 'LOG_TYPE') if logtype == 'dummy': new_log = DummyLogger() else: new_log = StdoutLogger() new_log.set_debug() self.app.debug = True self.log = new_log else: logtype = config.get('cache_server', 'LOG_TYPE') if logtype == 'file': logfile = config.get('cache_server', 'LOG_FILE') new_log = FileLogger(logfile) elif logtype == 'syslog': syslogaddress = config.get('cache_server', 'SYSLOG_ADDRESS') syslogfacility = config.get('cache_server', 'SYSLOG_FACILITY') new_log = SysLogger(syslogaddress, syslogfacility) elif logtype == 'dummy': new_log = DummyLogger() elif logtype == 'http': url = config.get('cache_server', 'HTTP_LOG_URL') method = config.get('cache_server', 'HTTP_LOG_METHOD') fallback_file = config.get('cache_server', 'HTTP_LOG_FILE_FAILURE') new_log = HTTPLogger(url=url, method=method, fallback_file=fallback_file) else: new_log = StdoutLogger() log_level = config.get('cache_server', 'LOG_LEVEL', default='INFO') if log_level == 'DEBUG': new_log.set_debug() self.app.debug = True elif log_level == 'INFO': new_log.set_info() self.app.debug = False elif log_level == 'ERROR': new_log.set_error() self.app.debug = False elif log_level in ('WARN', 'WARNING'): new_log.set_warn() self.app.debug = False new_log.name = self.name self.log = new_log self.app._logger = self.log def load_config(self, reload=False): # backup config backup_config = self._config # create config config = helpers.PlivoConfig(self.configfile) try: # read config config.read() if not reload: # create first logger if starting self.create_logger(config=config) self.log.info("Starting ...") self.log.warn("Logger %s" % str(self.log)) self.app.secret_key = config.get('cache_server', 'SECRET_KEY') self.app.config['MAX_CONTENT_LENGTH'] = 1024 * 10240 self.http_address = config.get('cache_server', 'HTTP_ADDRESS') self.http_host, http_port = self.http_address.split(':', 1) self.http_port = int(http_port) # load cache params self.redis_host = config.get('cache_server', 'REDIS_HOST', default='') self.redis_port = config.get('cache_server', 'REDIS_PORT', default='') self.redis_db = config.get('cache_server', 'REDIS_DB', default='') # create new cache self.create_cache(config=config) self.log.warn("Cache %s" % str(self.cache)) # set wsgi mode _wsgi_mode = config.get('cache_server', 'WSGI_MODE', default='wsgi') if _wsgi_mode in ('pywsgi', 'python', 'py'): self._wsgi_mode = PyWSGIServer else: self._wsgi_mode = WSGIServer if reload: # create new logger if reloading self.create_logger(config=config) self.log.warn("New logger %s" % str(self.log)) # create new cache self.create_cache(config=config) self.log.warn("New cache %s" % str(self.cache)) # allowed ips to access cache server allowed_ips = config.get('common', 'ALLOWED_IPS', default='') if not allowed_ips.strip(): self.allowed_ips = [] else: self.allowed_ips = [ ip.strip() for ip in allowed_ips.split(',') ] # set new config self._config = config self.log.info("Config : %s" % str(self._config.dumps())) except Exception, e: if backup_config: self._config = backup_config self.load_config() self.log.warn("Error reloading config: %s" % str(e)) self.log.warn("Rollback to the last config") self.log.info("Config : %s" % str(self._config.dumps())) else: sys.stderr.write("Error loading config: %s" % str(e)) sys.stderr.flush() raise e def reload(self): self.log.warn("Reload ...") self.load_config(reload=True) self.log.warn("Reload done") def do_daemon(self): """This will daemonize the current application Two settings from our configuration files are also used to run the daemon under a determine user & group. USER : determine the user running the daemon GROUP : determine the group running the daemon """ # get user/group from config user = self._config.get('cache_server', 'USER', default=None) group = self._config.get('cache_server', 'GROUP', default=None) if not user or not group: uid = os.getuid() user = pwd.getpwuid(uid)[0] gid = os.getgid() group = grp.getgrgid(gid)[0] # daemonize now plivo.utils.daemonize.daemon(user, group, path='/', pidfile=self._pidfile, other_groups=()) def sig_term(self, *args): """if we receive a term signal, we will shutdown properly """ self.log.warn("Shutdown ...") self.stop() sys.exit(0) def sig_hup(self, *args): self.reload() def stop(self): """Method stop stop the infinite loop from start method and close the socket """ self._run = False def start(self): """start method is where we decide to : * catch term signal * run as daemon * start the http server """ self.log.info("CacheServer starting ...") # catch SIG_TERM gevent.signal(signal.SIGTERM, self.sig_term) gevent.signal(signal.SIGHUP, self.sig_hup) # run self._run = True if self._daemon: self.do_daemon() # start http server self.log.info("CacheServer started at: 'http://%s'" % self.http_address) # Start cache server try: self.http_server.serve_forever() except (SystemExit, KeyboardInterrupt): pass # finish here self.log.info("CacheServer Exited") def main(): parser = optparse.OptionParser() parser.add_option("-c", "--configfile", action="store", type="string", dest="configfile", help="use plivo config file (argument is mandatory)", metavar="CONFIGFILE") parser.add_option("-p", "--pidfile", action="store", type="string", dest="pidfile", help="write pid to PIDFILE (argument is mandatory)", metavar="PIDFILE") (options, args) = parser.parse_args() configfile = options.configfile pidfile = options.pidfile if not configfile: configfile = './etc/plivo/default.conf' if not os.path.isfile(configfile): raise SystemExit("Error : Default config file mising at '%s'. Please specify -c <configfilepath>" %configfile) if not pidfile: pidfile='/tmp/plivo_cache.pid' server = PlivoCacheServer(configfile=configfile, pidfile=pidfile, daemon=False) server.start() if __name__ == '__main__': main()

37.211921

122

0.559797

from gevent import monkey monkey.patch_all() import grp import os import pwd import signal import sys import optparse from flask import Flask import gevent from gevent.wsgi import WSGIServer from gevent.pywsgi import WSGIServer as PyWSGIServer from plivo.rest.freeswitch.cacheapi import PlivoCacheApi import plivo.utils.daemonize from plivo.rest.freeswitch import cacheurls, helpers, cacheapi from plivo.utils.logger import StdoutLogger, FileLogger, SysLogger, DummyLogger, HTTPLogger class PlivoCacheServer(PlivoCacheApi): """Class PlivoCacheServer""" name = 'PlivoCacheServer' def __init__(self, configfile, daemon=False, pidfile='/tmp/plivo_cache.pid'): self._daemon = daemon self._run = False self._pidfile = pidfile self.configfile = configfile self._wsgi_mode = WSGIServer self.app = Flask(self.name) self.cache = None self._config = None self.load_config() for path, func_desc in cacheurls.URLS.iteritems(): func, methods = func_desc fn = getattr(self, func.__name__) self.app.add_url_rule(path, func.__name__, fn, methods=methods) self.log.info("Listening HTTP") self.log.info("%s mode set" % str(self._wsgi_mode)) self.http_server = self._wsgi_mode((self.http_host, self.http_port), self.app, log=self.log) def create_cache(self, config): self.redis_host = config.get('cache_server', 'REDIS_HOST', default='') self.redis_port = config.get('cache_server', 'REDIS_PORT', default='') self.redis_db = config.get('cache_server', 'REDIS_DB', default='') self.redis_pw = config.get('cache_server', 'REDIS_PASSWORD', default=None) self.proxy_url = config.get('cache_server', 'PROXY_URL', default=None) self.http_timeout = int(config.get('cache_server', 'HTTP_TIMEOUT', default=60)) if self.redis_host and self.redis_port and self.redis_db: self.cache = cacheapi.ResourceCache(self.redis_host, int(self.redis_port), int(self.redis_db), self.redis_pw, self.proxy_url, self.http_timeout) return True self.log.error("Cannot run cache server, cache not set !") raise Exception("Cannot run cache server, cache not set !") def get_log(self): return self.log def get_config(self): return self._config def get_cache(self): return self.cache def create_logger(self, config): """This will create a logger using helpers.PlivoConfig instance Based on the settings in the configuration file, LOG_TYPE will determine if we will log in file, syslog, stdout, http or dummy (no log) """ if self._daemon is False: logtype = config.get('cache_server', 'LOG_TYPE') if logtype == 'dummy': new_log = DummyLogger() else: new_log = StdoutLogger() new_log.set_debug() self.app.debug = True self.log = new_log else: logtype = config.get('cache_server', 'LOG_TYPE') if logtype == 'file': logfile = config.get('cache_server', 'LOG_FILE') new_log = FileLogger(logfile) elif logtype == 'syslog': syslogaddress = config.get('cache_server', 'SYSLOG_ADDRESS') syslogfacility = config.get('cache_server', 'SYSLOG_FACILITY') new_log = SysLogger(syslogaddress, syslogfacility) elif logtype == 'dummy': new_log = DummyLogger() elif logtype == 'http': url = config.get('cache_server', 'HTTP_LOG_URL') method = config.get('cache_server', 'HTTP_LOG_METHOD') fallback_file = config.get('cache_server', 'HTTP_LOG_FILE_FAILURE') new_log = HTTPLogger(url=url, method=method, fallback_file=fallback_file) else: new_log = StdoutLogger() log_level = config.get('cache_server', 'LOG_LEVEL', default='INFO') if log_level == 'DEBUG': new_log.set_debug() self.app.debug = True elif log_level == 'INFO': new_log.set_info() self.app.debug = False elif log_level == 'ERROR': new_log.set_error() self.app.debug = False elif log_level in ('WARN', 'WARNING'): new_log.set_warn() self.app.debug = False new_log.name = self.name self.log = new_log self.app._logger = self.log def load_config(self, reload=False): backup_config = self._config config = helpers.PlivoConfig(self.configfile) try: config.read() if not reload: self.create_logger(config=config) self.log.info("Starting ...") self.log.warn("Logger %s" % str(self.log)) self.app.secret_key = config.get('cache_server', 'SECRET_KEY') self.app.config['MAX_CONTENT_LENGTH'] = 1024 * 10240 self.http_address = config.get('cache_server', 'HTTP_ADDRESS') self.http_host, http_port = self.http_address.split(':', 1) self.http_port = int(http_port) self.redis_host = config.get('cache_server', 'REDIS_HOST', default='') self.redis_port = config.get('cache_server', 'REDIS_PORT', default='') self.redis_db = config.get('cache_server', 'REDIS_DB', default='') self.create_cache(config=config) self.log.warn("Cache %s" % str(self.cache)) _wsgi_mode = config.get('cache_server', 'WSGI_MODE', default='wsgi') if _wsgi_mode in ('pywsgi', 'python', 'py'): self._wsgi_mode = PyWSGIServer else: self._wsgi_mode = WSGIServer if reload: self.create_logger(config=config) self.log.warn("New logger %s" % str(self.log)) self.create_cache(config=config) self.log.warn("New cache %s" % str(self.cache)) allowed_ips = config.get('common', 'ALLOWED_IPS', default='') if not allowed_ips.strip(): self.allowed_ips = [] else: self.allowed_ips = [ ip.strip() for ip in allowed_ips.split(',') ] self._config = config self.log.info("Config : %s" % str(self._config.dumps())) except Exception, e: if backup_config: self._config = backup_config self.load_config() self.log.warn("Error reloading config: %s" % str(e)) self.log.warn("Rollback to the last config") self.log.info("Config : %s" % str(self._config.dumps())) else: sys.stderr.write("Error loading config: %s" % str(e)) sys.stderr.flush() raise e def reload(self): self.log.warn("Reload ...") self.load_config(reload=True) self.log.warn("Reload done") def do_daemon(self): """This will daemonize the current application Two settings from our configuration files are also used to run the daemon under a determine user & group. USER : determine the user running the daemon GROUP : determine the group running the daemon """ user = self._config.get('cache_server', 'USER', default=None) group = self._config.get('cache_server', 'GROUP', default=None) if not user or not group: uid = os.getuid() user = pwd.getpwuid(uid)[0] gid = os.getgid() group = grp.getgrgid(gid)[0] plivo.utils.daemonize.daemon(user, group, path='/', pidfile=self._pidfile, other_groups=()) def sig_term(self, *args): """if we receive a term signal, we will shutdown properly """ self.log.warn("Shutdown ...") self.stop() sys.exit(0) def sig_hup(self, *args): self.reload() def stop(self): """Method stop stop the infinite loop from start method and close the socket """ self._run = False def start(self): """start method is where we decide to : * catch term signal * run as daemon * start the http server """ self.log.info("CacheServer starting ...") gevent.signal(signal.SIGTERM, self.sig_term) gevent.signal(signal.SIGHUP, self.sig_hup) self._run = True if self._daemon: self.do_daemon() self.log.info("CacheServer started at: 'http://%s'" % self.http_address) try: self.http_server.serve_forever() except (SystemExit, KeyboardInterrupt): pass self.log.info("CacheServer Exited") def main(): parser = optparse.OptionParser() parser.add_option("-c", "--configfile", action="store", type="string", dest="configfile", help="use plivo config file (argument is mandatory)", metavar="CONFIGFILE") parser.add_option("-p", "--pidfile", action="store", type="string", dest="pidfile", help="write pid to PIDFILE (argument is mandatory)", metavar="PIDFILE") (options, args) = parser.parse_args() configfile = options.configfile pidfile = options.pidfile if not configfile: configfile = './etc/plivo/default.conf' if not os.path.isfile(configfile): raise SystemExit("Error : Default config file mising at '%s'. Please specify -c <configfilepath>" %configfile) if not pidfile: pidfile='/tmp/plivo_cache.pid' server = PlivoCacheServer(configfile=configfile, pidfile=pidfile, daemon=False) server.start() if __name__ == '__main__': main()

false

true

f71306cdaf57f6277c680b055dcbfff2c9f23428

1,567

py

Python

integrations-and-supported-tools/optuna/scripts/Neptune_Optuna_integration_customize_callback.py

neptune-ai/examples

e64cfaadb028e2187063fc43768dfee44074729b

[ "MIT" ]

15

2021-06-11T16:35:15.000Z

2022-03-29T15:53:59.000Z

integrations-and-supported-tools/optuna/scripts/Neptune_Optuna_integration_customize_callback.py

neptune-ai/examples

e64cfaadb028e2187063fc43768dfee44074729b

[ "MIT" ]

12

2021-04-26T13:07:50.000Z

2021-11-15T10:50:03.000Z

integrations-and-supported-tools/optuna/scripts/Neptune_Optuna_integration_customize_callback.py

neptune-ai/examples

e64cfaadb028e2187063fc43768dfee44074729b

[ "MIT" ]

10

2021-05-07T16:28:18.000Z

2022-02-28T21:47:11.000Z

import lightgbm as lgb import neptune.new as neptune import neptune.new.integrations.optuna as optuna_utils import optuna from sklearn.datasets import load_breast_cancer from sklearn.metrics import roc_auc_score from sklearn.model_selection import train_test_split def objective(trial): data, target = load_breast_cancer(return_X_y=True) train_x, test_x, train_y, test_y = train_test_split(data, target, test_size=0.25) dtrain = lgb.Dataset(train_x, label=train_y) param = { "verbose": -1, "objective": "binary", "metric": "binary_logloss", "num_leaves": trial.suggest_int("num_leaves", 2, 256), "feature_fraction": trial.suggest_uniform("feature_fraction", 0.2, 1.0), "bagging_fraction": trial.suggest_uniform("bagging_fraction", 0.2, 1.0), "min_child_samples": trial.suggest_int("min_child_samples", 3, 100), } gbm = lgb.train(param, dtrain) preds = gbm.predict(test_x) accuracy = roc_auc_score(test_y, preds) return accuracy # Create a Neptune Run run = neptune.init( api_token="ANONYMOUS", project="common/optuna-integration" ) # you can pass your credentials here # Create a NeptuneCallback for Optuna neptune_callback = optuna_utils.NeptuneCallback( run, plots_update_freq=10, log_plot_slice=False, log_plot_contour=False, ) # Pass NeptuneCallback to Optuna Study .optimize() study = optuna.create_study(direction="maximize") study.optimize(objective, n_trials=50, callbacks=[neptune_callback]) # Stop logging to a Neptune Run run.stop()

30.72549

85

0.730696

import lightgbm as lgb import neptune.new as neptune import neptune.new.integrations.optuna as optuna_utils import optuna from sklearn.datasets import load_breast_cancer from sklearn.metrics import roc_auc_score from sklearn.model_selection import train_test_split def objective(trial): data, target = load_breast_cancer(return_X_y=True) train_x, test_x, train_y, test_y = train_test_split(data, target, test_size=0.25) dtrain = lgb.Dataset(train_x, label=train_y) param = { "verbose": -1, "objective": "binary", "metric": "binary_logloss", "num_leaves": trial.suggest_int("num_leaves", 2, 256), "feature_fraction": trial.suggest_uniform("feature_fraction", 0.2, 1.0), "bagging_fraction": trial.suggest_uniform("bagging_fraction", 0.2, 1.0), "min_child_samples": trial.suggest_int("min_child_samples", 3, 100), } gbm = lgb.train(param, dtrain) preds = gbm.predict(test_x) accuracy = roc_auc_score(test_y, preds) return accuracy run = neptune.init( api_token="ANONYMOUS", project="common/optuna-integration" ) neptune_callback = optuna_utils.NeptuneCallback( run, plots_update_freq=10, log_plot_slice=False, log_plot_contour=False, ) study = optuna.create_study(direction="maximize") study.optimize(objective, n_trials=50, callbacks=[neptune_callback]) run.stop()

true

f713088ab00e8c25a1a72f8168121f4e7a2c67f4

1,476

py

Python

src/ice/persistence/config_file_backing_store.py

geraldhumphries/Ice

ec466e85407361bbbc87b9e484fe427c1769b4fe

[ "MIT" ]

null

src/ice/persistence/config_file_backing_store.py

geraldhumphries/Ice

ec466e85407361bbbc87b9e484fe427c1769b4fe

[ "MIT" ]

null

src/ice/persistence/config_file_backing_store.py

geraldhumphries/Ice

ec466e85407361bbbc87b9e484fe427c1769b4fe

[ "MIT" ]

null

# encoding: utf-8 """ config_file_backing_store.py Created by Scott on 2014-08-12. Copyright (c) 2014 Scott Rice. All rights reserved. """ import ConfigParser import backing_store class ConfigFileBackingStore(backing_store.BackingStore): def __init__(self, path): super(ConfigFileBackingStore, self).__init__(path) self.configParser = ConfigParser.RawConfigParser() self.configParser.read(self.path) def identifiers(self): return self.configParser.sections() def add_identifier(self, ident): try: self.configParser.add_section(ident) except ConfigParser.DuplicateSectionError: raise ValueError("The identifier `%s` already exists" % str(ident)) def remove_identifier(self, ident): self.configParser.remove_section(ident) def keys(self, ident): try: return self.configParser.options(ident) except ConfigParser.NoSectionError: raise ValueError("No identifier named `%s` exists" % str(ident)) def get(self, ident, key, default=None): try: val = self.configParser.get(ident, key.lower()) return val if val != "" else default except ConfigParser.NoOptionError: return default def set(self, ident, key, value): self.configParser.set(ident, key.lower(), value) def save(self): try: with open(self.path, "w") as configFile: self.configParser.write(configFile) except IOError: raise IOError("Cannot save data to `%s`. Permission Denied")

26.836364

73

0.70935

import ConfigParser import backing_store class ConfigFileBackingStore(backing_store.BackingStore): def __init__(self, path): super(ConfigFileBackingStore, self).__init__(path) self.configParser = ConfigParser.RawConfigParser() self.configParser.read(self.path) def identifiers(self): return self.configParser.sections() def add_identifier(self, ident): try: self.configParser.add_section(ident) except ConfigParser.DuplicateSectionError: raise ValueError("The identifier `%s` already exists" % str(ident)) def remove_identifier(self, ident): self.configParser.remove_section(ident) def keys(self, ident): try: return self.configParser.options(ident) except ConfigParser.NoSectionError: raise ValueError("No identifier named `%s` exists" % str(ident)) def get(self, ident, key, default=None): try: val = self.configParser.get(ident, key.lower()) return val if val != "" else default except ConfigParser.NoOptionError: return default def set(self, ident, key, value): self.configParser.set(ident, key.lower(), value) def save(self): try: with open(self.path, "w") as configFile: self.configParser.write(configFile) except IOError: raise IOError("Cannot save data to `%s`. Permission Denied")

true

f71308ef91bdc04340e4aa7f18beafcd02c04cc6

3,880

py

Python

lib/searchengine.py

mavlyutovrus/light_search

6b0d2d78de99820ca366c6c1bd8efce93a789100

[ "MIT" ]

null

lib/searchengine.py

mavlyutovrus/light_search

6b0d2d78de99820ca366c6c1bd8efce93a789100

[ "MIT" ]

null

lib/searchengine.py

mavlyutovrus/light_search

6b0d2d78de99820ca366c6c1bd8efce93a789100

[ "MIT" ]

null

# This file was automatically generated by SWIG (http://www.swig.org). # Version 3.0.8 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. from sys import version_info if version_info >= (2, 6, 0): def swig_import_helper(): from os.path import dirname import imp fp = None try: fp, pathname, description = imp.find_module('_searchengine', [dirname(__file__)]) except ImportError: import _searchengine return _searchengine if fp is not None: try: _mod = imp.load_module('_searchengine', fp, pathname, description) finally: fp.close() return _mod _searchengine = swig_import_helper() del swig_import_helper else: import _searchengine del version_info try: _swig_property = property except NameError: pass # Python < 2.2 doesn't have 'property'. def _swig_setattr_nondynamic(self, class_type, name, value, static=1): if (name == "thisown"): return self.this.own(value) if (name == "this"): if type(value).__name__ == 'SwigPyObject': self.__dict__[name] = value return method = class_type.__swig_setmethods__.get(name, None) if method: return method(self, value) if (not static): if _newclass: object.__setattr__(self, name, value) else: self.__dict__[name] = value else: raise AttributeError("You cannot add attributes to %s" % self) def _swig_setattr(self, class_type, name, value): return _swig_setattr_nondynamic(self, class_type, name, value, 0) def _swig_getattr_nondynamic(self, class_type, name, static=1): if (name == "thisown"): return self.this.own() method = class_type.__swig_getmethods__.get(name, None) if method: return method(self) if (not static): return object.__getattr__(self, name) else: raise AttributeError(name) def _swig_getattr(self, class_type, name): return _swig_getattr_nondynamic(self, class_type, name, 0) def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except Exception: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) try: _object = object _newclass = 1 except AttributeError: class _object: pass _newclass = 0 class TSearchIndex(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, TSearchIndex, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, TSearchIndex, name) __repr__ = _swig_repr def __init__(self, indexLocation): this = _searchengine.new_TSearchIndex(indexLocation) try: self.this.append(this) except Exception: self.this = this __swig_destroy__ = _searchengine.delete_TSearchIndex __del__ = lambda self: None def ExecuteQuery(self, keysStr, firstResult2Return, results2Return, objectsStr): return _searchengine.TSearchIndex_ExecuteQuery(self, keysStr, firstResult2Return, results2Return, objectsStr) TSearchIndex_swigregister = _searchengine.TSearchIndex_swigregister TSearchIndex_swigregister(TSearchIndex) cvar = _searchengine.cvar OBJ_BITS = cvar.OBJ_BITS SEGMENT_POS_BITS = cvar.SEGMENT_POS_BITS WEIGHT_BITS = cvar.WEIGHT_BITS NON_SEGMENT_BITS = cvar.NON_SEGMENT_BITS MAX_SEGMENTS_PER_OBJECT = cvar.MAX_SEGMENTS_PER_OBJECT MAX_WORDS4QUERY = cvar.MAX_WORDS4QUERY MAX_KEYS2CONSIDER = cvar.MAX_KEYS2CONSIDER CRUDE_FILTER_TRIM_PROPORTION = cvar.CRUDE_FILTER_TRIM_PROPORTION MAX_OCCURENCES2RETURN = cvar.MAX_OCCURENCES2RETURN # This file is compatible with both classic and new-style classes.

30.551181

117

0.688402

from sys import version_info if version_info >= (2, 6, 0): def swig_import_helper(): from os.path import dirname import imp fp = None try: fp, pathname, description = imp.find_module('_searchengine', [dirname(__file__)]) except ImportError: import _searchengine return _searchengine if fp is not None: try: _mod = imp.load_module('_searchengine', fp, pathname, description) finally: fp.close() return _mod _searchengine = swig_import_helper() del swig_import_helper else: import _searchengine del version_info try: _swig_property = property except NameError: pass def _swig_setattr_nondynamic(self, class_type, name, value, static=1): if (name == "thisown"): return self.this.own(value) if (name == "this"): if type(value).__name__ == 'SwigPyObject': self.__dict__[name] = value return method = class_type.__swig_setmethods__.get(name, None) if method: return method(self, value) if (not static): if _newclass: object.__setattr__(self, name, value) else: self.__dict__[name] = value else: raise AttributeError("You cannot add attributes to %s" % self) def _swig_setattr(self, class_type, name, value): return _swig_setattr_nondynamic(self, class_type, name, value, 0) def _swig_getattr_nondynamic(self, class_type, name, static=1): if (name == "thisown"): return self.this.own() method = class_type.__swig_getmethods__.get(name, None) if method: return method(self) if (not static): return object.__getattr__(self, name) else: raise AttributeError(name) def _swig_getattr(self, class_type, name): return _swig_getattr_nondynamic(self, class_type, name, 0) def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except Exception: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) try: _object = object _newclass = 1 except AttributeError: class _object: pass _newclass = 0 class TSearchIndex(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, TSearchIndex, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, TSearchIndex, name) __repr__ = _swig_repr def __init__(self, indexLocation): this = _searchengine.new_TSearchIndex(indexLocation) try: self.this.append(this) except Exception: self.this = this __swig_destroy__ = _searchengine.delete_TSearchIndex __del__ = lambda self: None def ExecuteQuery(self, keysStr, firstResult2Return, results2Return, objectsStr): return _searchengine.TSearchIndex_ExecuteQuery(self, keysStr, firstResult2Return, results2Return, objectsStr) TSearchIndex_swigregister = _searchengine.TSearchIndex_swigregister TSearchIndex_swigregister(TSearchIndex) cvar = _searchengine.cvar OBJ_BITS = cvar.OBJ_BITS SEGMENT_POS_BITS = cvar.SEGMENT_POS_BITS WEIGHT_BITS = cvar.WEIGHT_BITS NON_SEGMENT_BITS = cvar.NON_SEGMENT_BITS MAX_SEGMENTS_PER_OBJECT = cvar.MAX_SEGMENTS_PER_OBJECT MAX_WORDS4QUERY = cvar.MAX_WORDS4QUERY MAX_KEYS2CONSIDER = cvar.MAX_KEYS2CONSIDER CRUDE_FILTER_TRIM_PROPORTION = cvar.CRUDE_FILTER_TRIM_PROPORTION MAX_OCCURENCES2RETURN = cvar.MAX_OCCURENCES2RETURN # This file is compatible with both classic and new-style classes.

true

f71308fd0107b25762f8b57a132aa2e42da40da3

19,704

py

Python

control_parameters_step/tk_control_parameters.py

paulsaxe/control_parameters_step

e789c8c329d150683a44e8a8cdfef3c61e2158a6

[ "BSD-3-Clause" ]

null

control_parameters_step/tk_control_parameters.py

paulsaxe/control_parameters_step

e789c8c329d150683a44e8a8cdfef3c61e2158a6

[ "BSD-3-Clause" ]

null

control_parameters_step/tk_control_parameters.py

paulsaxe/control_parameters_step

e789c8c329d150683a44e8a8cdfef3c61e2158a6

[ "BSD-3-Clause" ]

null

# -*- coding: utf-8 -*- """The graphical part of a Control Parameters step""" import seamm from seamm_util import ureg, Q_, units_class # noqa: F401 import seamm_widgets as sw import control_parameters_step # noqa: F401 import Pmw import pprint # noqa: F401 import tkinter as tk import tkinter.ttk as ttk class TkControlParameters(seamm.TkNode): """ The graphical part of a Control Parameters step in a flowchart. Attributes ---------- tk_flowchart : TkFlowchart = None The flowchart that we belong to. node : Node = None The corresponding node of the non-graphical flowchart namespace : str The namespace of the current step. sub_tk_flowchart : TkFlowchart A graphical Flowchart representing a subflowchart canvas: tkCanvas = None The Tk Canvas to draw on dialog : Dialog The Pmw dialog object x : int = None The x-coordinate of the center of the picture of the node y : int = None The y-coordinate of the center of the picture of the node w : int = 200 The width in pixels of the picture of the node h : int = 50 The height in pixels of the picture of the node self[widget] : dict A dictionary of tk widgets built using the information contained in Control Parameters_parameters.py See Also -------- ControlParameters, TkControlParameters, ControlParametersParameters, """ def __init__( self, tk_flowchart=None, node=None, canvas=None, x=None, y=None, w=200, h=50 ): """ Initialize a graphical node. Parameters ---------- tk_flowchart: Tk_Flowchart The graphical flowchart that we are in. node: Node The non-graphical node for this step. namespace: str The stevedore namespace for finding sub-nodes. canvas: Canvas The Tk canvas to draw on. x: float The x position of the nodes center on the canvas. y: float The y position of the nodes cetner on the canvas. w: float The nodes graphical width, in pixels. h: float The nodes graphical height, in pixels. Returns ------- None """ self.dialog = None self._variables = None # temporary copy when editing self._new_variable_dialog = None self._new = {} # Widgets for the new variable dialog self._edit_variable_dialog = None self._edit = {} # Widgets for the edit variable dialog super().__init__( tk_flowchart=tk_flowchart, node=node, canvas=canvas, x=x, y=y, w=w, h=h ) def create_dialog(self): """ Create the dialog. A set of widgets will be chosen by default based on what is specified in the Control Parameters_parameters module. Parameters ---------- None Returns ------- None See Also -------- TkControlParameters.reset_dialog """ frame = super().create_dialog("Edit Parameters") # make it large! screen_w = self.dialog.winfo_screenwidth() screen_h = self.dialog.winfo_screenheight() w = int(0.9 * screen_w) h = int(0.8 * screen_h) x = int(0.05 * screen_w / 2) y = int(0.1 * screen_h / 2) self.dialog.geometry("{}x{}+{}+{}".format(w, h, x, y)) # The information about widgets is held in self['xxxx'], i.e. this # class is in part a dictionary of widgets. This makes accessing # the widgets easier and allows loops, etc. # Shortcut for parameters P = self.node.parameters # Then create the widgets self["variables"] = sw.ScrolledColumns( frame, columns=[ "", "Name", "Type", "NArgs", "Optional", "Overwrite?", "Default", "Help", ], ) # any remaining widgets for key in P: if key not in self: self[key] = P[key].widget(frame) def reset_dialog(self, widget=None): """Layout the widgets in the dialog. The widgets are chosen by default from the information in Control Parameters_parameter. This function simply lays them out row by row with aligned labels. You may wish a more complicated layout that is controlled by values of some of the control parameters. If so, edit or override this method Parameters ---------- widget : Tk Widget = None Returns ------- None See Also -------- TkControlParameters.create_dialog """ # Remove any widgets previously packed frame = self["frame"] for slave in frame.grid_slaves(): slave.grid_forget() # Shortcut for parameters P = self.node.parameters # keep track of the row in a variable, so that the layout is flexible # if e.g. rows are skipped to control such as 'method' here row = 0 widgets = [] # Variables table first key = "variables" self[key].grid(row=row, column=0, sticky=tk.NSEW) frame.columnconfigure(0, weight=1) frame.rowconfigure(row, weight=1) widgets.append(self[key]) row += 1 for key in P: if self[key] not in widgets: self[key].grid(row=row, column=0, sticky=tk.EW) widgets.append(self[key]) row += 1 # Align the labels sw.align_labels(widgets) def right_click(self, event): """ Handles the right click event on the node. Parameters ---------- event : Tk Event Returns ------- None See Also -------- TkControlParameters.edit """ super().right_click(event) self.popup_menu.add_command(label="Edit..", command=self.edit) self.popup_menu.tk_popup(event.x_root, event.y_root, 0) def edit(self): """Present a dialog for editing the Control Parameters input Parameters ---------- None Returns ------- None See Also -------- TkControlParameters.right_click """ if self.dialog is None: self.create_dialog() P = self.node.parameters self._variables = P["variables"].value self.reset_dialog() self.reset_table() self.dialog.activate(geometry="centerscreenfirst") def handle_dialog(self, result): """Handle the closing of the edit dialog What to do depends on the button used to close the dialog. If the user closes it by clicking the 'x' of the dialog window, None is returned, which we take as equivalent to cancel. Parameters ---------- result : None or str The value of this variable depends on what the button the user clicked. Returns ------- None """ if result is None or result == "Cancel": self.dialog.deactivate(result) self._variables = None return if result == "Help": # display help!!! return if result != "OK": self.dialog.deactivate(result) raise RuntimeError("Don't recognize dialog result '{}'".format(result)) self.dialog.deactivate(result) # Shortcut for parameters P = self.node.parameters # Get the values for all the widgets. P["variables"].value = self._variables self._variables = None for key in P: if key != "variables": P[key].set_from_widget() def handle_help(self): """Shows the help to the user when click on help button. Parameters ---------- None Returns ------- None """ print("Help not implemented yet for Control Parameters!") def add_variable(self): """Add a new variable to the table.""" # Post dialog to fill out the new variable if self._new_variable_dialog is None: self.create_new_variable_dialog() self._new["name"].set("") self._new["type"].set("float") self._new["optional"].set("Yes") self._new["nargs"].set("a single value") self._new["overwrite"].set("No") self._new["default"].set("") self._new["choices"].set("[]") self._new["help"].set("") self._new_variable_dialog.activate(geometry="centerscreenfirst") def create_new_variable_dialog(self): """ Create a dialog for adding new variables. Parameters ---------- None Returns ------- None """ if self._new_variable_dialog is not None: return dialog = self._new_variable_dialog = Pmw.Dialog( self.dialog.interior(), buttons=("OK", "Cancel"), defaultbutton="OK", title="Add Variable", command=self.handle_new_variable_dialog, ) self._new_variable_dialog.withdraw() # Create a frame to hold everything in the dialog frame = self._new["frame"] = ttk.Frame(dialog.interior()) frame.pack(expand=tk.YES, fill=tk.BOTH) # Then create the widgets self._new["name"] = sw.LabeledEntry(frame, labeltext="Name") self._new["optional"] = sw.LabeledCombobox( frame, labeltext="Optional?:", values=("Yes", "No"), state="readonly" ) self._new["type"] = sw.LabeledCombobox( frame, labeltext="Type:", values=( "str", "int", "float", "bool", "file", ), state="readonly", ) self._new["nargs"] = sw.LabeledCombobox( frame, labeltext="Number of values:", values=( "a single value", "an optional value", "zero or more values", "one or more values", ), state="readonly", ) self._new["overwrite"] = sw.LabeledCombobox( frame, labeltext="Overwrite if exists:", values=("Yes", "No"), state="readonly", ) self._new["default"] = sw.LabeledEntry(frame, labeltext="Default:") self._new["choices"] = sw.LabeledEntry(frame, labeltext="Choices:") self._new["help"] = sw.LabeledEntry(frame, labeltext="Help:", width=80) # and lay them out self.reset_new_variable_dialog() def reset_new_variable_dialog(self): """Lay the dialog out based on the contents.""" # Remove any widgets previously packed frame = self._new["frame"] for slave in frame.grid_slaves(): slave.grid_forget() row = 0 widgets = [] for key in ("name", "type", "nargs", "optional", "overwrite"): self._new[key].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._new[key]) row += 1 type_ = self._new["type"].get() if type_ != "bool": w = self._new["default"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 w = self._new["choices"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 self._new["help"].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._new["help"]) row += 1 sw.align_labels(widgets) def handle_new_variable_dialog(self, result): """Handle the closing of the new variable dialog What to do depends on the button used to close the dialog. If the user closes it by clicking the 'x' of the dialog window, None is returned, which we take as equivalent to cancel. Parameters ---------- result : None or str The value of this variable depends on what the button the user clicked. Returns ------- None """ if result is None or result == "Cancel": self._new_variable_dialog.deactivate(result) self._variables = None return if result != "OK": self._new_variable_dialog.deactivate(result) raise RuntimeError(f"Don't recognize new variable dialog result '{result}'") self._new_variable_dialog.deactivate(result) name = self._new["name"].get() if name in self._variables: raise KeyError(f"Duplicate variable name: '{name}'") data = self._variables[name] = {} for key, w in self._new.items(): if key not in ("frame", "name"): data[key] = w.get() self.reset_table() def reset_table(self): """Update the table of variables to the current data.""" table = self["variables"] frame = table.table.interior() table.clear() row = 0 for name, data in self._variables.items(): table[row, 0] = ttk.Button( frame, text="Edit", width=5, command=lambda: self.edit_variable(name), takefocus=True, ) table[row, 1] = name table[row, 2] = data["type"] table[row, 3] = data["nargs"] table[row, 4] = data["optional"] table[row, 5] = data["overwrite"] if data["type"] != "bool": table[row, 6] = data["default"] table[row, 7] = data["help"] row += 1 # a button to add new variables... table[row, 0] = ttk.Button( frame, text="+", width=5, command=self.add_variable, takefocus=True ) table.update_idletasks() def edit_variable(self, name): """Edit the values associated with a variable.""" # Post dialog to fill out the new variable if self._edit_variable_dialog is None: self.create_edit_variable_dialog() self._edit_variable_dialog.configure( command=lambda result: self.handle_edit_variable_dialog( name, result ) # noqa: E501 ) data = self._variables[name] for key, w in self._edit.items(): if key == "name": w.set(name) elif key != "frame": w.set(data[key]) self._edit_variable_dialog.activate(geometry="centerscreenfirst") def create_edit_variable_dialog(self): """ Create a dialog for adding edit variables. Parameters ---------- None Returns ------- None """ if self._edit_variable_dialog is not None: return dialog = self._edit_variable_dialog = Pmw.Dialog( self.dialog.interior(), buttons=("OK", "Cancel"), defaultbutton="OK", title="Edit Variable", command=lambda: self.handle_edit_variable_dialog, ) self._edit_variable_dialog.withdraw() # Create a frame to hold everything in the dialog frame = self._edit["frame"] = ttk.Frame(dialog.interior()) frame.pack(expand=tk.YES, fill=tk.BOTH) # Then create the widgets self._edit["name"] = sw.LabeledEntry(frame, labeltext="Name") self._edit["optional"] = sw.LabeledCombobox( frame, labeltext="Type:", values=("Yes", "No"), state="readonly" ) self._edit["type"] = sw.LabeledCombobox( frame, labeltext="Type:", values=( "str", "int", "float", "bool", "file", ), state="readonly", ) self._edit["nargs"] = sw.LabeledCombobox( frame, labeltext="Number of values:", values=( "a single value", "an optional value", "zero or more values", "one or more", ), state="readonly", ) self._edit["overwrite"] = sw.LabeledCombobox( frame, labeltext="Overwrite if exists:", values=("Yes", "No"), state="readonly", ) self._edit["default"] = sw.LabeledEntry(frame, labeltext="Default:") self._edit["choices"] = sw.LabeledEntry(frame, labeltext="Choices:") self._edit["optional"] = sw.LabeledCombobox( frame, labeltext="Optional?:", values=("Yes", "No"), state="readonly" ) self._edit["help"] = sw.LabeledEntry(frame, labeltext="Help:", width=80) # and lay them out self.reset_edit_variable_dialog() def reset_edit_variable_dialog(self): """Lay the dialog out based on the contents.""" # Remove any widgets previously packed frame = self._edit["frame"] for slave in frame.grid_slaves(): slave.grid_forget() row = 0 widgets = [] for key in ("name", "type", "nargs", "optional", "overwrite"): self._edit[key].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._edit[key]) row += 1 type_ = self._edit["type"].get() if type_ != "bool": w = self._edit["default"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 w = self._edit["choices"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 self._edit["help"].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._edit["help"]) row += 1 sw.align_labels(widgets) def handle_edit_variable_dialog(self, name, result): """Handle the closing of the edit variable dialog What to do depends on the button used to close the dialog. If the user closes it by clicking the 'x' of the dialog window, None is returned, which we take as equivalent to cancel. Parameters ---------- result : None or str The value of this variable depends on what the button the user clicked. Returns ------- None """ if result is None or result == "Cancel": self._edit_variable_dialog.deactivate(result) self._variables = None return if result != "OK": self._edit_variable_dialog.deactivate(result) raise RuntimeError( f"Don't recognize edit variable dialog result '{result}'" ) self._edit_variable_dialog.deactivate(result) new_name = self._edit["name"].get().lstrip("-") if new_name == name: data = self._variables[name] else: del self._variables[name] name = new_name data = self._variables[name] = {} for key, w in self._edit.items(): if key not in ("frame", "name"): data[key] = w.get() self.reset_table()

29.719457

88

0.537911

import seamm from seamm_util import ureg, Q_, units_class import seamm_widgets as sw import control_parameters_step import Pmw import pprint import tkinter as tk import tkinter.ttk as ttk class TkControlParameters(seamm.TkNode): def __init__( self, tk_flowchart=None, node=None, canvas=None, x=None, y=None, w=200, h=50 ): self.dialog = None self._variables = None self._new_variable_dialog = None self._new = {} self._edit_variable_dialog = None self._edit = {} super().__init__( tk_flowchart=tk_flowchart, node=node, canvas=canvas, x=x, y=y, w=w, h=h ) def create_dialog(self): frame = super().create_dialog("Edit Parameters") screen_w = self.dialog.winfo_screenwidth() screen_h = self.dialog.winfo_screenheight() w = int(0.9 * screen_w) h = int(0.8 * screen_h) x = int(0.05 * screen_w / 2) y = int(0.1 * screen_h / 2) self.dialog.geometry("{}x{}+{}+{}".format(w, h, x, y)) P = self.node.parameters self["variables"] = sw.ScrolledColumns( frame, columns=[ "", "Name", "Type", "NArgs", "Optional", "Overwrite?", "Default", "Help", ], ) for key in P: if key not in self: self[key] = P[key].widget(frame) def reset_dialog(self, widget=None): frame = self["frame"] for slave in frame.grid_slaves(): slave.grid_forget() P = self.node.parameters row = 0 widgets = [] key = "variables" self[key].grid(row=row, column=0, sticky=tk.NSEW) frame.columnconfigure(0, weight=1) frame.rowconfigure(row, weight=1) widgets.append(self[key]) row += 1 for key in P: if self[key] not in widgets: self[key].grid(row=row, column=0, sticky=tk.EW) widgets.append(self[key]) row += 1 sw.align_labels(widgets) def right_click(self, event): super().right_click(event) self.popup_menu.add_command(label="Edit..", command=self.edit) self.popup_menu.tk_popup(event.x_root, event.y_root, 0) def edit(self): if self.dialog is None: self.create_dialog() P = self.node.parameters self._variables = P["variables"].value self.reset_dialog() self.reset_table() self.dialog.activate(geometry="centerscreenfirst") def handle_dialog(self, result): if result is None or result == "Cancel": self.dialog.deactivate(result) self._variables = None return if result == "Help": return if result != "OK": self.dialog.deactivate(result) raise RuntimeError("Don't recognize dialog result '{}'".format(result)) self.dialog.deactivate(result) # Shortcut for parameters P = self.node.parameters # Get the values for all the widgets. P["variables"].value = self._variables self._variables = None for key in P: if key != "variables": P[key].set_from_widget() def handle_help(self): print("Help not implemented yet for Control Parameters!") def add_variable(self): # Post dialog to fill out the new variable if self._new_variable_dialog is None: self.create_new_variable_dialog() self._new["name"].set("") self._new["type"].set("float") self._new["optional"].set("Yes") self._new["nargs"].set("a single value") self._new["overwrite"].set("No") self._new["default"].set("") self._new["choices"].set("[]") self._new["help"].set("") self._new_variable_dialog.activate(geometry="centerscreenfirst") def create_new_variable_dialog(self): if self._new_variable_dialog is not None: return dialog = self._new_variable_dialog = Pmw.Dialog( self.dialog.interior(), buttons=("OK", "Cancel"), defaultbutton="OK", title="Add Variable", command=self.handle_new_variable_dialog, ) self._new_variable_dialog.withdraw() # Create a frame to hold everything in the dialog frame = self._new["frame"] = ttk.Frame(dialog.interior()) frame.pack(expand=tk.YES, fill=tk.BOTH) # Then create the widgets self._new["name"] = sw.LabeledEntry(frame, labeltext="Name") self._new["optional"] = sw.LabeledCombobox( frame, labeltext="Optional?:", values=("Yes", "No"), state="readonly" ) self._new["type"] = sw.LabeledCombobox( frame, labeltext="Type:", values=( "str", "int", "float", "bool", "file", ), state="readonly", ) self._new["nargs"] = sw.LabeledCombobox( frame, labeltext="Number of values:", values=( "a single value", "an optional value", "zero or more values", "one or more values", ), state="readonly", ) self._new["overwrite"] = sw.LabeledCombobox( frame, labeltext="Overwrite if exists:", values=("Yes", "No"), state="readonly", ) self._new["default"] = sw.LabeledEntry(frame, labeltext="Default:") self._new["choices"] = sw.LabeledEntry(frame, labeltext="Choices:") self._new["help"] = sw.LabeledEntry(frame, labeltext="Help:", width=80) # and lay them out self.reset_new_variable_dialog() def reset_new_variable_dialog(self): # Remove any widgets previously packed frame = self._new["frame"] for slave in frame.grid_slaves(): slave.grid_forget() row = 0 widgets = [] for key in ("name", "type", "nargs", "optional", "overwrite"): self._new[key].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._new[key]) row += 1 type_ = self._new["type"].get() if type_ != "bool": w = self._new["default"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 w = self._new["choices"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 self._new["help"].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._new["help"]) row += 1 sw.align_labels(widgets) def handle_new_variable_dialog(self, result): if result is None or result == "Cancel": self._new_variable_dialog.deactivate(result) self._variables = None return if result != "OK": self._new_variable_dialog.deactivate(result) raise RuntimeError(f"Don't recognize new variable dialog result '{result}'") self._new_variable_dialog.deactivate(result) name = self._new["name"].get() if name in self._variables: raise KeyError(f"Duplicate variable name: '{name}'") data = self._variables[name] = {} for key, w in self._new.items(): if key not in ("frame", "name"): data[key] = w.get() self.reset_table() def reset_table(self): table = self["variables"] frame = table.table.interior() table.clear() row = 0 for name, data in self._variables.items(): table[row, 0] = ttk.Button( frame, text="Edit", width=5, command=lambda: self.edit_variable(name), takefocus=True, ) table[row, 1] = name table[row, 2] = data["type"] table[row, 3] = data["nargs"] table[row, 4] = data["optional"] table[row, 5] = data["overwrite"] if data["type"] != "bool": table[row, 6] = data["default"] table[row, 7] = data["help"] row += 1 table[row, 0] = ttk.Button( frame, text="+", width=5, command=self.add_variable, takefocus=True ) table.update_idletasks() def edit_variable(self, name): if self._edit_variable_dialog is None: self.create_edit_variable_dialog() self._edit_variable_dialog.configure( command=lambda result: self.handle_edit_variable_dialog( name, result ) ) data = self._variables[name] for key, w in self._edit.items(): if key == "name": w.set(name) elif key != "frame": w.set(data[key]) self._edit_variable_dialog.activate(geometry="centerscreenfirst") def create_edit_variable_dialog(self): if self._edit_variable_dialog is not None: return dialog = self._edit_variable_dialog = Pmw.Dialog( self.dialog.interior(), buttons=("OK", "Cancel"), defaultbutton="OK", title="Edit Variable", command=lambda: self.handle_edit_variable_dialog, ) self._edit_variable_dialog.withdraw() frame = self._edit["frame"] = ttk.Frame(dialog.interior()) frame.pack(expand=tk.YES, fill=tk.BOTH) self._edit["name"] = sw.LabeledEntry(frame, labeltext="Name") self._edit["optional"] = sw.LabeledCombobox( frame, labeltext="Type:", values=("Yes", "No"), state="readonly" ) self._edit["type"] = sw.LabeledCombobox( frame, labeltext="Type:", values=( "str", "int", "float", "bool", "file", ), state="readonly", ) self._edit["nargs"] = sw.LabeledCombobox( frame, labeltext="Number of values:", values=( "a single value", "an optional value", "zero or more values", "one or more", ), state="readonly", ) self._edit["overwrite"] = sw.LabeledCombobox( frame, labeltext="Overwrite if exists:", values=("Yes", "No"), state="readonly", ) self._edit["default"] = sw.LabeledEntry(frame, labeltext="Default:") self._edit["choices"] = sw.LabeledEntry(frame, labeltext="Choices:") self._edit["optional"] = sw.LabeledCombobox( frame, labeltext="Optional?:", values=("Yes", "No"), state="readonly" ) self._edit["help"] = sw.LabeledEntry(frame, labeltext="Help:", width=80) self.reset_edit_variable_dialog() def reset_edit_variable_dialog(self): frame = self._edit["frame"] for slave in frame.grid_slaves(): slave.grid_forget() row = 0 widgets = [] for key in ("name", "type", "nargs", "optional", "overwrite"): self._edit[key].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._edit[key]) row += 1 type_ = self._edit["type"].get() if type_ != "bool": w = self._edit["default"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 w = self._edit["choices"] w.grid(row=row, column=0, sticky=tk.EW) widgets.append(w) row += 1 self._edit["help"].grid(row=row, column=0, sticky=tk.EW) widgets.append(self._edit["help"]) row += 1 sw.align_labels(widgets) def handle_edit_variable_dialog(self, name, result): if result is None or result == "Cancel": self._edit_variable_dialog.deactivate(result) self._variables = None return if result != "OK": self._edit_variable_dialog.deactivate(result) raise RuntimeError( f"Don't recognize edit variable dialog result '{result}'" ) self._edit_variable_dialog.deactivate(result) new_name = self._edit["name"].get().lstrip("-") if new_name == name: data = self._variables[name] else: del self._variables[name] name = new_name data = self._variables[name] = {} for key, w in self._edit.items(): if key not in ("frame", "name"): data[key] = w.get() self.reset_table()

true

f7130949530e3c8080cfb33ad2f69288e627d3c5

151

py

Python

lux/_config/__init__.py

piyushg9794/lux

f5be470f5a4837db2746c950bebe2694665c25dc

[ "Apache-2.0" ]

null

lux/_config/__init__.py

piyushg9794/lux

f5be470f5a4837db2746c950bebe2694665c25dc

[ "Apache-2.0" ]

null

lux/_config/__init__.py

piyushg9794/lux

f5be470f5a4837db2746c950bebe2694665c25dc

[ "Apache-2.0" ]

null

from lux._config import config from lux._config.config import ( register_action, remove_action, actions, update_actions, config, )

16.777778

32

0.708609

from lux._config import config from lux._config.config import ( register_action, remove_action, actions, update_actions, config, )

true

f71309838213fda3d2ccfb8239566aa6840f11d6

1,693

py

Python

tests/unittests/azure_namespace_import/azure_namespace_import.py

gohar94/azure-functions-python-worker

4322e53ddbcc1eea40c1b061b42653336d9003f6

[ "MIT" ]

277

2018-01-25T23:13:03.000Z

2022-02-22T06:12:04.000Z

tests/unittests/azure_namespace_import/azure_namespace_import.py

gohar94/azure-functions-python-worker

4322e53ddbcc1eea40c1b061b42653336d9003f6

[ "MIT" ]

731

2018-01-18T18:54:38.000Z

2022-03-29T00:01:46.000Z

tests/unittests/azure_namespace_import/azure_namespace_import.py

YunchuWang/azure-functions-python-worker

1f23e038a506c6412e4efbf07eb471a6afab0c2a

[ "MIT" ]

109

2018-01-18T02:22:57.000Z

2022-02-15T18:59:54.000Z

# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. import os import sys import shutil import asyncio from azure_functions_worker import protos from azure_functions_worker import testutils async def vertify_nested_namespace_import(): test_env = {} request = protos.FunctionEnvironmentReloadRequest( environment_variables=test_env) request_msg = protos.StreamingMessage( request_id='0', function_environment_reload_request=request) disp = testutils.create_dummy_dispatcher() # Mock intepreter starts in placeholder mode import azure.module_a as mod_a # noqa: F401 # Mock function specialization, load customer's libraries and functionapps ns_root = os.path.join( testutils.UNIT_TESTS_ROOT, 'azure_namespace_import', 'namespace_location_b') test_path = os.path.join(ns_root, 'azure', 'namespace_b', 'module_b') test_mod_path = os.path.join(test_path, 'test_module.py') os.makedirs(test_path) with open(test_mod_path, 'w') as f: f.write('MESSAGE = "module_b is imported"') try: # Mock a customer uses test_module if sys.argv[1].lower() == 'true': await disp._handle__function_environment_reload_request( request_msg) from azure.namespace_b.module_b import test_module print(test_module.MESSAGE) except ModuleNotFoundError: print('module_b fails to import') finally: # Cleanup shutil.rmtree(ns_root) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(vertify_nested_namespace_import()) loop.close()

30.232143

78

0.705848

import os import sys import shutil import asyncio from azure_functions_worker import protos from azure_functions_worker import testutils async def vertify_nested_namespace_import(): test_env = {} request = protos.FunctionEnvironmentReloadRequest( environment_variables=test_env) request_msg = protos.StreamingMessage( request_id='0', function_environment_reload_request=request) disp = testutils.create_dummy_dispatcher() import azure.module_a as mod_a ns_root = os.path.join( testutils.UNIT_TESTS_ROOT, 'azure_namespace_import', 'namespace_location_b') test_path = os.path.join(ns_root, 'azure', 'namespace_b', 'module_b') test_mod_path = os.path.join(test_path, 'test_module.py') os.makedirs(test_path) with open(test_mod_path, 'w') as f: f.write('MESSAGE = "module_b is imported"') try: # Mock a customer uses test_module if sys.argv[1].lower() == 'true': await disp._handle__function_environment_reload_request( request_msg) from azure.namespace_b.module_b import test_module print(test_module.MESSAGE) except ModuleNotFoundError: print('module_b fails to import') finally: # Cleanup shutil.rmtree(ns_root) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(vertify_nested_namespace_import()) loop.close()

true

f7130a131ee35ac383e4e4fbe789078fd95b52cf

6,620

py

Python

tests/test_utils.py

KaczuH/pykechain

2bc734ddf2df4926e7ad5612197e50fee6e24071

[ "Apache-2.0" ]

5

2017-05-03T12:19:51.000Z

2021-07-07T11:55:50.000Z

tests/test_utils.py

KaczuH/pykechain

2bc734ddf2df4926e7ad5612197e50fee6e24071

[ "Apache-2.0" ]

593

2016-12-22T15:41:54.000Z

2022-03-22T12:39:49.000Z

tests/test_utils.py

KaczuH/pykechain

2bc734ddf2df4926e7ad5612197e50fee6e24071

[ "Apache-2.0" ]

5

2017-03-13T17:36:28.000Z

2021-06-24T09:37:55.000Z

from unittest import TestCase from pykechain.utils import is_url, is_valid_email, Empty, get_in_chunks from tests.classes import SixTestCase class TestIsURL(SixTestCase): def test_is_url_returns_true_on_valid_url(self): addresses = [ u"http://foobar.dk", u"http://foobar.museum/foobar", u"http://fo.com", u"http://FOO.com", u"http://foo.com/blah_blah", u"http://foo.com/blah_blah/", u"http://foo.com/blah_blah_(wikipedia)", u"http://foo.com/blah_blah_(wikipedia)_(again)", u"http://www.example.com/wpstyle/?p=364", u"https://www.example.com/foo/?bar=baz&inga=42&quux", u"https://www.example.com?bar=baz", u"http://✪df.ws/123", u"http://userid:password@example.com:8080", u"http://userid@example.com", u"http://userid@example.com:8080/", u"http://userid:password@example.com", u"http://142.42.1.1/", u"http://142.42.1.1:8080/", u"http://⌘.ws/", u"http://foo.com/blah_(wikipedia)#cite-1", u"http://foo.com/unicode_(✪)_in_parens", u"http://foo.com/(something)?after=parens", u"http://☺.damowmow.com/", u"http://code.google.com/events/#&product=browser", u"http://j.mp", u"ftp://foo.bar/baz", u"http://foo.bar/?q=Test%20URL-encoded%20stuff", u"http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", u"http://1337.net", u"http://a.b-c.de", u"http://223.255.255.254", u"http://127.0.10.150", u"http://localhost", u"http://localhost:8000", u"http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html", u"http://[1080:0:0:0:8:800:200C:417A]/index.html", u"http://[3ffe:2a00:100:7031::1]", u"http://[1080::8:800:200C:417A]/foo", u"http://[::192.9.5.5]/ipng", u"http://[::FFFF:129.144.52.38]:80/index.html", u"http://[2010:836B:4179::836B:4179]", ] for address in addresses: with self.subTest(address): self.assertTrue(is_url(address), "should be a valid address: '{}'".format(address)) def test_is_url_returns_False_on_failed_url(self): failed_addresses = [ "http://foobar", "foobar.dk", "http://127.0.0/asdf", "http://foobar.d", "http://foobar.12", "http://foobar", "htp://foobar.com", "http://foobar..com", "http://fo..com", "http://", "http://.", "http://..", "http://../", "http://?", "http://??", "http://??/", "http://#", "http://##", "http://##/", "http://foo.bar?q=Spaces should be encoded", "//", "//a", "///a", "///", "http:///a", "foo.com", "rdar://1234", "h://test", "http:// shouldfail.com", ":// should fail", "http://foo.bar/foo(bar)baz quux", "ftps://foo.bar/", "http://-error-.invalid/", "http://a.b--c.de/", "http://-a.b.co", "http://a.b-.co", "http://0.0.0.0", "http://10.1.1.0", "http://10.1.1.255", "http://224.1.1.1", "http://1.1.1.1.1", "http://123.123.123", "http://3628126748", "http://.www.foo.bar/", "http://www.foo.bar./", "http://.www.foo.bar./", "http://127.12.0.260", 'http://example.com/">user@example.com', "http://[2010:836B:4179::836B:4179", "http://2010:836B:4179::836B:4179", "http://2010:836B:4179::836B:4179:80/index.html", ] for address in failed_addresses: with self.subTest(address): self.assertFalse(is_url(address), "should be a invalid address: '{}'".format(address)) class TestIsEmail(SixTestCase): def test_is_email_returns_true_on_valid_url(self): valid_addresses = [ "some@domain.org", "email@example.com", "firstname.lastname@example.com", "email@subdomain.example.com", "firstname+lastname@example.com", "email@123.123.123.123", "email@[123.123.123.123]", '"email"@example.com', "1234567890@example.com", "email@example-one.com", "_______@example.com", "email@example.name", "email@example.museum", "email@example.co.jp", "firstname-lastname@example.com", ] for email in valid_addresses: with self.subTest(email): self.assertTrue(is_valid_email(email), "should be a valid address: '{}'".format(email)) def test_is_email_returns_false_on_invalid_url(self): invalid_addresses = [ "plainaddress", "#@%^%#$@#$@#.com", "@example.com", "Joe Smith <email@example.com>", "email.example.com", "email@example@example.com", ".email@example.com", "email.@example.com", "email..email@example.com", "あいうえお@example.com", "email@example.com (Joe Smith)", "email@example", "email@-example.com", "email@example..com", "Abc..123@example.com", "”(),:;<>[\]@example.com", "just”not”right@example.com", 'this\ is"really"not\allowed@example.com', ] for email in invalid_addresses: with self.subTest(email): self.assertFalse(is_valid_email(email), "should be an invalid address: '{}'".format(email)) class TestEmpty(TestCase): def test_singleton(self): empty_1 = Empty() empty_2 = Empty() self.assertEqual(empty_1, empty_2) self.assertIs(empty_1, empty_2) self.assertIsNot(empty_1, Empty) class TestChunks(TestCase): def test_get_in_chunks(self): chunks = get_in_chunks( lst=list(range(77)), chunk_size=9, ) import types self.assertIsInstance(chunks, types.GeneratorType) chunks_list = list(chunks) self.assertEqual(9, len(chunks_list))

35.212766

107

0.488671

from unittest import TestCase from pykechain.utils import is_url, is_valid_email, Empty, get_in_chunks from tests.classes import SixTestCase class TestIsURL(SixTestCase): def test_is_url_returns_true_on_valid_url(self): addresses = [ u"http://foobar.dk", u"http://foobar.museum/foobar", u"http://fo.com", u"http://FOO.com", u"http://foo.com/blah_blah", u"http://foo.com/blah_blah/", u"http://foo.com/blah_blah_(wikipedia)", u"http://foo.com/blah_blah_(wikipedia)_(again)", u"http://www.example.com/wpstyle/?p=364", u"https://www.example.com/foo/?bar=baz&inga=42&quux", u"https://www.example.com?bar=baz", u"http://✪df.ws/123", u"http://userid:password@example.com:8080", u"http://userid@example.com", u"http://userid@example.com:8080/", u"http://userid:password@example.com", u"http://142.42.1.1/", u"http://142.42.1.1:8080/", u"http://⌘.ws/", u"http://foo.com/blah_(wikipedia)#cite-1", u"http://foo.com/unicode_(✪)_in_parens", u"http://foo.com/(something)?after=parens", u"http://☺.damowmow.com/", u"http://code.google.com/events/#&product=browser", u"http://j.mp", u"ftp://foo.bar/baz", u"http://foo.bar/?q=Test%20URL-encoded%20stuff", u"http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", u"http://1337.net", u"http://a.b-c.de", u"http://223.255.255.254", u"http://127.0.10.150", u"http://localhost", u"http://localhost:8000", u"http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html", u"http://[1080:0:0:0:8:800:200C:417A]/index.html", u"http://[3ffe:2a00:100:7031::1]", u"http://[1080::8:800:200C:417A]/foo", u"http://[::192.9.5.5]/ipng", u"http://[::FFFF:129.144.52.38]:80/index.html", u"http://[2010:836B:4179::836B:4179]", ] for address in addresses: with self.subTest(address): self.assertTrue(is_url(address), "should be a valid address: '{}'".format(address)) def test_is_url_returns_False_on_failed_url(self): failed_addresses = [ "http://foobar", "foobar.dk", "http://127.0.0/asdf", "http://foobar.d", "http://foobar.12", "http://foobar", "htp://foobar.com", "http://foobar..com", "http://fo..com", "http://", "http://.", "http://..", "http://../", "http://?", "http://??", "http://??/", "http://#", "http://##", "http://##/", "http://foo.bar?q=Spaces should be encoded", "//", "//a", "///a", "///", "http:///a", "foo.com", "rdar://1234", "h://test", "http:// shouldfail.com", ":// should fail", "http://foo.bar/foo(bar)baz quux", "ftps://foo.bar/", "http://-error-.invalid/", "http://a.b--c.de/", "http://-a.b.co", "http://a.b-.co", "http://0.0.0.0", "http://10.1.1.0", "http://10.1.1.255", "http://224.1.1.1", "http://1.1.1.1.1", "http://123.123.123", "http://3628126748", "http://.www.foo.bar/", "http://www.foo.bar./", "http://.www.foo.bar./", "http://127.12.0.260", 'http://example.com/">user@example.com', "http://[2010:836B:4179::836B:4179", "http://2010:836B:4179::836B:4179", "http://2010:836B:4179::836B:4179:80/index.html", ] for address in failed_addresses: with self.subTest(address): self.assertFalse(is_url(address), "should be a invalid address: '{}'".format(address)) class TestIsEmail(SixTestCase): def test_is_email_returns_true_on_valid_url(self): valid_addresses = [ "some@domain.org", "email@example.com", "firstname.lastname@example.com", "email@subdomain.example.com", "firstname+lastname@example.com", "email@123.123.123.123", "email@[123.123.123.123]", '"email"@example.com', "1234567890@example.com", "email@example-one.com", "_______@example.com", "email@example.name", "email@example.museum", "email@example.co.jp", "firstname-lastname@example.com", ] for email in valid_addresses: with self.subTest(email): self.assertTrue(is_valid_email(email), "should be a valid address: '{}'".format(email)) def test_is_email_returns_false_on_invalid_url(self): invalid_addresses = [ "plainaddress", "#@%^%#$@#$@#.com", "@example.com", "Joe Smith <email@example.com>", "email.example.com", "email@example@example.com", ".email@example.com", "email.@example.com", "email..email@example.com", "あいうえお@example.com", "email@example.com (Joe Smith)", "email@example", "email@-example.com", "email@example..com", "Abc..123@example.com", "”(),:;<>[\]@example.com", "just”not”right@example.com", 'this\ is"really"not\allowed@example.com', ] for email in invalid_addresses: with self.subTest(email): self.assertFalse(is_valid_email(email), "should be an invalid address: '{}'".format(email)) class TestEmpty(TestCase): def test_singleton(self): empty_1 = Empty() empty_2 = Empty() self.assertEqual(empty_1, empty_2) self.assertIs(empty_1, empty_2) self.assertIsNot(empty_1, Empty) class TestChunks(TestCase): def test_get_in_chunks(self): chunks = get_in_chunks( lst=list(range(77)), chunk_size=9, ) import types self.assertIsInstance(chunks, types.GeneratorType) chunks_list = list(chunks) self.assertEqual(9, len(chunks_list))

true

f7130a19783ebc588021ea51528389bdf45f5fd1

1,611

py

Python

src/scripts/create_shelters_thumbnails.py

rodekruis/shelter-database

99f96bf06a7287e925b7385dbf7cc363caf4a2bd

[ "MIT" ]

9

2016-07-12T06:41:48.000Z

2022-02-03T05:55:17.000Z

src/scripts/create_shelters_thumbnails.py

rodekruis/shelter-database

99f96bf06a7287e925b7385dbf7cc363caf4a2bd

[ "MIT" ]

22

2016-09-06T05:36:37.000Z

2021-09-07T23:41:26.000Z

src/scripts/create_shelters_thumbnails.py

rodekruis/shelter-database

99f96bf06a7287e925b7385dbf7cc363caf4a2bd

[ "MIT" ]

3

2016-08-19T05:37:08.000Z

2017-02-20T06:58:03.000Z

#! /usr/bin/python #-*- coding:utf-8 -* import os import conf from web.models import Shelter, ShelterPicture from bootstrap import db from PIL import Image def create_shelters_thumbnails(): shelters = Shelter.query.all() pictures = ShelterPicture.query.all() for picture in pictures: filepath = os.path.join(conf.SHELTERS_PICTURES_SERVER_PATH, str(picture.shelter_id), picture.file_name) basename, ext = os.path.splitext(picture.file_name) if str(basename.rpartition('_')[2]) == 'thumbnail': continue try: thumbname = basename + '_thumbnail' + ext new_thumbpath = os.path.join(conf.SHELTERS_PICTURES_SERVER_PATH, str(picture.shelter_id), thumbname) if os.path.exists(new_thumbpath): if db.session.query(ShelterPicture).filter_by(file_name=thumbname).first(): continue im = Image.open(filepath) im.thumbnail((300,200), Image.ANTIALIAS) im.save(new_thumbpath, 'JPEG', quality=70, optimize=True, progressive=True) new_picture = ShelterPicture(file_name=thumbname, shelter_id=picture.shelter_id, category_id=picture.category_id, is_main_picture=picture.is_main_picture) db.session.add(new_picture) db.session.commit() except: print("Failed to create thumbnail for shelter {}, file {}".format(picture.shelter_id, picture.file_name)) continue

40.275

117

0.610801

import os import conf from web.models import Shelter, ShelterPicture from bootstrap import db from PIL import Image def create_shelters_thumbnails(): shelters = Shelter.query.all() pictures = ShelterPicture.query.all() for picture in pictures: filepath = os.path.join(conf.SHELTERS_PICTURES_SERVER_PATH, str(picture.shelter_id), picture.file_name) basename, ext = os.path.splitext(picture.file_name) if str(basename.rpartition('_')[2]) == 'thumbnail': continue try: thumbname = basename + '_thumbnail' + ext new_thumbpath = os.path.join(conf.SHELTERS_PICTURES_SERVER_PATH, str(picture.shelter_id), thumbname) if os.path.exists(new_thumbpath): if db.session.query(ShelterPicture).filter_by(file_name=thumbname).first(): continue im = Image.open(filepath) im.thumbnail((300,200), Image.ANTIALIAS) im.save(new_thumbpath, 'JPEG', quality=70, optimize=True, progressive=True) new_picture = ShelterPicture(file_name=thumbname, shelter_id=picture.shelter_id, category_id=picture.category_id, is_main_picture=picture.is_main_picture) db.session.add(new_picture) db.session.commit() except: print("Failed to create thumbnail for shelter {}, file {}".format(picture.shelter_id, picture.file_name)) continue

true

f7130b08ef855e3db989ab8893f0a61477a14c5f

71

py

Python

dataset/__init__.py

kylematoba/pest

749b3f02cc98d3bf06dc7e2142306fc6d252f3ce

[ "MIT" ]

2

2021-10-30T06:48:05.000Z

2021-12-17T07:19:49.000Z

dataset/__init__.py

kylematoba/pest

749b3f02cc98d3bf06dc7e2142306fc6d252f3ce

[ "MIT" ]

null

dataset/__init__.py

kylematoba/pest

749b3f02cc98d3bf06dc7e2142306fc6d252f3ce

[ "MIT" ]

1

2022-02-21T14:51:08.000Z

from .wrapper import get_dataset from .adversarial import class_indices

35.5

38

0.873239

from .wrapper import get_dataset from .adversarial import class_indices

true

f7130b8a5d6998992435ddd3445404406a4916cf

119

py

Python

mmdet/models/decision_net/__init__.py

ruyueshuo/MaskTrackRCNN

3c6ada36be3c2b2df32176349ec5c0ee5b24e724

[ "Apache-2.0" ]

1

2020-01-03T08:30:42.000Z

mmdet/models/decision_net/__init__.py

ruyueshuo/MaskTrackRCNN

3c6ada36be3c2b2df32176349ec5c0ee5b24e724

[ "Apache-2.0" ]

null

mmdet/models/decision_net/__init__.py

ruyueshuo/MaskTrackRCNN

3c6ada36be3c2b2df32176349ec5c0ee5b24e724

[ "Apache-2.0" ]

null

from .env import DecisionEnv from .base import BaseRL from .ddpg import * from .dqn import * __all__ = ['DecisionEnv']

19.833333

28

0.747899

from .env import DecisionEnv from .base import BaseRL from .ddpg import * from .dqn import * __all__ = ['DecisionEnv']

true

f7130d848e1f61bab8213b7f7c4bdf4bf08d3b40

4,184

py

Python

openGaussBase/testcase/GUC/RUN_STATISTICS/Opengauss_Function_Guc_Run_Statistics_Case0003.py

opengauss-mirror/Yat

aef107a8304b94e5d99b4f1f36eb46755eb8919e

[ "MulanPSL-1.0" ]

null

openGaussBase/testcase/GUC/RUN_STATISTICS/Opengauss_Function_Guc_Run_Statistics_Case0003.py

opengauss-mirror/Yat

aef107a8304b94e5d99b4f1f36eb46755eb8919e

[ "MulanPSL-1.0" ]

null

openGaussBase/testcase/GUC/RUN_STATISTICS/Opengauss_Function_Guc_Run_Statistics_Case0003.py

opengauss-mirror/Yat

aef107a8304b94e5d99b4f1f36eb46755eb8919e

[ "MulanPSL-1.0" ]

null

""" Copyright (c) 2022 Huawei Technologies Co.,Ltd. openGauss is licensed under Mulan PSL v2. You can use this software according to the terms and conditions of the Mulan PSL v2. You may obtain a copy of Mulan PSL v2 at: http://license.coscl.org.cn/MulanPSL2 THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. See the Mulan PSL v2 for more details. """ """ Case Type : GUC Case Name : 修改track_counts为off，观察预期结果； Description : 1、查询track_counts默认值； show track_counts; 2、修改track_counts为off，重启使其生效，并校验其预期结果； gs_guc set -D {cluster/dn1} -c "track_counts=off" gs_om -t stop && gs_om -t start show track_counts; 3、重启后做简单DML 4、恢复默认值； Expect : 1、显示默认值； 2、参数修改成功，校验修改后系统参数值为off； 3、DML无报错 4、恢复默认值成功； History : """ import sys import unittest sys.path.append(sys.path[0] + "/../") from testcase.utils.Logger import Logger from testcase.utils.Constant import Constant from testcase.utils.CommonSH import CommonSH logger = Logger() commonsh = CommonSH('PrimaryDbUser') class Guctestcase(unittest.TestCase): def setUp(self): logger.info("------------------------Opengauss_Function_Guc_Run_Statistics_Case0003开始执行-----------------------------") self.Constant = Constant() def test_guc(self): logger.info("查询track_counts 期望：默认值on") sql_cmd = commonsh.execut_db_sql('''show track_counts;''') logger.info(sql_cmd) self.assertEqual("on", sql_cmd.split("\n")[-2].strip()) logger.info("修改track_counts为off，重启使其生效，期望：设置成功") result = commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_counts=off') self.assertTrue(result) logger.info("期望：重启后查询结果为off") commonsh.restart_db_cluster() status = commonsh.get_db_cluster_status() self.assertTrue("Normal" in status or "Degraded" in status) sql_cmd = commonsh.execut_db_sql('''show track_counts;''') logger.info(sql_cmd) self.assertEqual("off", sql_cmd.split("\n")[-2].strip()) logger.info('执行DML 期望：执行成功') sql_cmd = commonsh.execut_db_sql(''' begin for i in 0..1000 loop drop table if exists test cascade; create table test(c_int int); insert into test values(1),(2); update test set c_int = 5 where c_int = 1; delete from test where c_int = 2; end loop; end; select * from test; ''') logger.info(sql_cmd) self.assertNotIn(self.Constant.SQL_WRONG_MSG[1], sql_cmd) logger.info("恢复默认值") logger.info("删除表") sql_cmd = commonsh.execut_db_sql('''drop table test cascade;''') logger.info(sql_cmd) self.assertIn(self.Constant.DROP_TABLE_SUCCESS,sql_cmd) result = commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_counts=on') self.assertTrue(result) result = commonsh.restart_db_cluster() logger.info(result) status = commonsh.get_db_cluster_status() logger.info(status) self.assertTrue("Normal" in status or "Degraded" in status) def tearDown(self): logger.info("恢复默认值") sql_cmd = commonsh.execut_db_sql('''show track_counts;''') if "on" not in sql_cmd: commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_counts=on') commonsh.restart_db_cluster() status = commonsh.get_db_cluster_status() logger.info(status) self.assertTrue("Normal" in status or "Degraded" in status) logger.info("-------------------------Opengauss_Function_Guc_Run_Statistics_Case0003执行结束---------------------------")

38.385321

126

0.595363

import sys import unittest sys.path.append(sys.path[0] + "/../") from testcase.utils.Logger import Logger from testcase.utils.Constant import Constant from testcase.utils.CommonSH import CommonSH logger = Logger() commonsh = CommonSH('PrimaryDbUser') class Guctestcase(unittest.TestCase): def setUp(self): logger.info("------------------------Opengauss_Function_Guc_Run_Statistics_Case0003开始执行-----------------------------") self.Constant = Constant() def test_guc(self): logger.info("查询track_counts 期望：默认值on") sql_cmd = commonsh.execut_db_sql('''show track_counts;''') logger.info(sql_cmd) self.assertEqual("on", sql_cmd.split("\n")[-2].strip()) logger.info("修改track_counts为off，重启使其生效，期望：设置成功") result = commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_counts=off') self.assertTrue(result) logger.info("期望：重启后查询结果为off") commonsh.restart_db_cluster() status = commonsh.get_db_cluster_status() self.assertTrue("Normal" in status or "Degraded" in status) sql_cmd = commonsh.execut_db_sql('''show track_counts;''') logger.info(sql_cmd) self.assertEqual("off", sql_cmd.split("\n")[-2].strip()) logger.info('执行DML 期望：执行成功') sql_cmd = commonsh.execut_db_sql(''' begin for i in 0..1000 loop drop table if exists test cascade; create table test(c_int int); insert into test values(1),(2); update test set c_int = 5 where c_int = 1; delete from test where c_int = 2; end loop; end; select * from test; ''') logger.info(sql_cmd) self.assertNotIn(self.Constant.SQL_WRONG_MSG[1], sql_cmd) logger.info("恢复默认值") logger.info("删除表") sql_cmd = commonsh.execut_db_sql('''drop table test cascade;''') logger.info(sql_cmd) self.assertIn(self.Constant.DROP_TABLE_SUCCESS,sql_cmd) result = commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_counts=on') self.assertTrue(result) result = commonsh.restart_db_cluster() logger.info(result) status = commonsh.get_db_cluster_status() logger.info(status) self.assertTrue("Normal" in status or "Degraded" in status) def tearDown(self): logger.info("恢复默认值") sql_cmd = commonsh.execut_db_sql('''show track_counts;''') if "on" not in sql_cmd: commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_counts=on') commonsh.restart_db_cluster() status = commonsh.get_db_cluster_status() logger.info(status) self.assertTrue("Normal" in status or "Degraded" in status) logger.info("-------------------------Opengauss_Function_Guc_Run_Statistics_Case0003执行结束---------------------------")

true

f7130df6ae5f73d9d9ed55e9e0eca965972ab216

12,178

py

Python

liegroups/torch/se2.py

mttgdd/liegroups

ca637bd461300d70d70f90bff7a18462d06f5f82

[ "MIT" ]

1

2021-04-27T16:51:34.000Z

liegroups/torch/se2.py

mttgdd/liegroups

ca637bd461300d70d70f90bff7a18462d06f5f82

[ "MIT" ]

null

liegroups/torch/se2.py

mttgdd/liegroups

ca637bd461300d70d70f90bff7a18462d06f5f82

[ "MIT" ]

null

import torch from . import _base from . import utils from .so2 import SO2Matrix class SE2Matrix(_base.SEMatrixBase): """See :mod:`liegroups.SE2`""" dim = 3 dof = 3 RotationType = SO2Matrix def adjoint(self): rot_part = self.rot.as_matrix() if rot_part.dim() < 3: rot_part = rot_part.unsqueeze(dim=0) # matrix --> batch trans = self.trans if trans.dim() < 2: # vector --> vectorbatch trans = trans.unsqueeze(dim=0) trans_part = trans.new_empty( trans.shape[0], trans.shape[1], 1) trans_part[:, 0, 0] = trans[:, 1] trans_part[:, 1, 0] = -trans[:, 0] bottom_row = trans.new_zeros(self.dof) bottom_row[-1] = 1. bottom_row = bottom_row.unsqueeze_(dim=0).unsqueeze_( dim=0).expand(trans.shape[0], 1, self.dof) return torch.cat([torch.cat([rot_part, trans_part], dim=2), bottom_row], dim=1).squeeze_() @classmethod def exp(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "xi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) rho = xi[:, 0:2] phi = xi[:, 2] rot = cls.RotationType.exp(phi) rot_jac = cls.RotationType.left_jacobian(phi) if rot_jac.dim() < 3: rot_jac.unsqueeze_(dim=0) if rho.dim() < 3: rho.unsqueeze_(dim=2) trans = torch.bmm(rot_jac, rho).squeeze_() return cls(rot, trans) @classmethod def inv_left_jacobian(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "xi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) rho = xi[:, 0:2] # translation part phi = xi[:, 2] # rotation part cos_phi = torch.cos(phi) sin_phi = torch.sin(phi) phi_sq = phi * phi small_angle_mask = utils.isclose(phi_sq, 0.) small_angle_inds = small_angle_mask.nonzero().squeeze_(dim=1) large_angle_mask = small_angle_mask.logical_not() large_angle_inds = large_angle_mask.nonzero().squeeze_(dim=1) jac = torch.zeros((xi.shape[0], cls.dof, cls.dof)).to(xi.device) jac[small_angle_inds, 0, 0] = -(96*(phi_sq[small_angle_inds] - 6))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 0, 1] = -(24*phi[small_angle_inds]*(phi_sq[small_angle_inds] - 12))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 0, 2] = (4*(12*phi[small_angle_inds]*rho[small_angle_inds,0] - 72*rho[small_angle_inds,1] + 12*phi_sq[small_angle_inds]*rho[small_angle_inds,1] - 12*phi_sq[small_angle_inds]*rho[small_angle_inds,1] + phi_sq[small_angle_inds]*phi_sq[small_angle_inds]*rho[small_angle_inds,1] + phi_sq[small_angle_inds]*phi[small_angle_inds]*rho[small_angle_inds,0]))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 1, 0] = (24*phi[small_angle_inds]*(phi_sq[small_angle_inds] - 12))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 1, 1] = -(96*(phi_sq[small_angle_inds] - 6))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 1, 2] = (4*(72*rho[small_angle_inds,0] - 12*phi_sq[small_angle_inds]*rho[small_angle_inds,0] + 12*phi[small_angle_inds]*rho[small_angle_inds,1] + 12*phi_sq[small_angle_inds]*rho[small_angle_inds,0] - phi_sq[small_angle_inds]*phi_sq[small_angle_inds]*rho[small_angle_inds,0] + phi_sq[small_angle_inds]*phi[small_angle_inds]*rho[small_angle_inds,1]))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[large_angle_inds, 0, 0] = (sin_phi[large_angle_inds]*phi[large_angle_inds])/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 0, 1] = -(phi[large_angle_inds]*(cos_phi[large_angle_inds] - 1))/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 0, 2] = (phi[large_angle_inds]*(rho[large_angle_inds,0] - 2*cos_phi[large_angle_inds]*rho[large_angle_inds,0] - phi[large_angle_inds]*rho[large_angle_inds,1] + cos_phi[large_angle_inds]**2*rho[large_angle_inds,0] + sin_phi[large_angle_inds]**2*rho[large_angle_inds,0] + cos_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,1] - sin_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,0]))/(phi_sq[large_angle_inds]*(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1)) jac[large_angle_inds, 1, 0] = (phi[large_angle_inds]*(cos_phi[large_angle_inds] - 1))/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 1, 1] = (sin_phi[large_angle_inds]*phi[large_angle_inds])/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 1, 2] = (phi[large_angle_inds]*(rho[large_angle_inds,1] - 2*cos_phi[large_angle_inds]*rho[large_angle_inds,1] + phi[large_angle_inds]*rho[large_angle_inds,0] + cos_phi[large_angle_inds]**2*rho[large_angle_inds,1] + sin_phi[large_angle_inds]**2*rho[large_angle_inds,1] - cos_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,0] - sin_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,1]))/(phi_sq[large_angle_inds]*(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1)) jac[:, 2, 0] = 0 jac[:, 2, 1] = 0 jac[:, 2, 2] = 1 return jac.squeeze_() @classmethod def left_jacobian(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "xi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) rho = xi[:, 0:2] # translation part phi = xi[:, 2] # rotation part cos_phi = torch.cos(phi) sin_phi = torch.sin(phi) phi_sq = phi * phi small_angle_mask = utils.isclose(phi_sq, 0.) small_angle_inds = small_angle_mask.nonzero().squeeze_(dim=1) large_angle_mask = small_angle_mask.logical_not() large_angle_inds = large_angle_mask.nonzero().squeeze_(dim=1) jac = torch.zeros((xi.shape[0], cls.dof, cls.dof)).to(xi.device) jac[small_angle_inds, 0, 0] = 1 - 1./6. * phi_sq[small_angle_inds] jac[small_angle_inds, 0, 1] = -(0.5 * phi[small_angle_inds] - 1./24. * phi[small_angle_inds] * phi_sq[small_angle_inds]) jac[small_angle_inds, 0, 2] = rho[small_angle_inds,1] / 2. + phi[small_angle_inds] * rho[small_angle_inds,0] / 6. jac[small_angle_inds, 1, 0] = 0.5 * phi[small_angle_inds] - 1./24. * phi[small_angle_inds] * phi_sq[small_angle_inds] jac[small_angle_inds, 1, 1] = 1 - 1./6. * phi_sq[small_angle_inds] jac[small_angle_inds, 1, 2] = -rho[small_angle_inds,0] / 2. + phi[small_angle_inds] * rho[small_angle_inds,1] / 6. jac[large_angle_inds, 0, 0] = sin_phi[large_angle_inds] / phi[large_angle_inds] jac[large_angle_inds, 0, 1] = -(1 - cos_phi[large_angle_inds]) / phi[large_angle_inds] jac[large_angle_inds, 0, 2] = ( rho[large_angle_inds,1] + phi[large_angle_inds]*rho[large_angle_inds,0] - rho[large_angle_inds,1]*cos_phi[large_angle_inds] - rho[large_angle_inds,0]*sin_phi[large_angle_inds])/phi_sq[large_angle_inds] jac[large_angle_inds, 1, 0] = (1 - cos_phi[large_angle_inds]) / phi[large_angle_inds] jac[large_angle_inds, 1, 1] = sin_phi[large_angle_inds] / phi[large_angle_inds] jac[large_angle_inds, 1, 2] = (-rho[large_angle_inds,0] + phi[large_angle_inds]*rho[large_angle_inds,1] + rho[large_angle_inds,0]*cos_phi[large_angle_inds] - rho[large_angle_inds,1]*sin_phi[large_angle_inds])/phi_sq[large_angle_inds] jac[:, 2, 0] = 0 jac[:, 2, 1] = 0 jac[:, 2, 2] = 1 return jac.squeeze_() def log(self): phi = self.rot.log() inv_rot_jac = self.RotationType.inv_left_jacobian(phi) if self.trans.dim() < 2: trans = self.trans.unsqueeze(dim=0) else: trans = self.trans if phi.dim() < 1: phi.unsqueeze_(dim=0) phi.unsqueeze_(dim=1) # because phi is 1-dimensional for SE2 if inv_rot_jac.dim() < 3: inv_rot_jac.unsqueeze_(dim=0) if trans.dim() < 3: trans = trans.unsqueeze(dim=2) rho = torch.bmm(inv_rot_jac, trans).squeeze_() if rho.dim() < 2: rho.unsqueeze_(dim=0) return torch.cat([rho, phi], dim=1).squeeze_() @classmethod def odot(cls, p, directional=False): if p.dim() < 2: p = p.unsqueeze(dim=0) # vector --> vectorbatch result = p.__class__(p.shape[0], p.shape[1], cls.dof).zero_() # Got euclidean coordinates if p.shape[1] == cls.dim - 1: # Assume scale parameter is 1 unless p is a direction # vector, in which case the scale is 0 if not directional: result[:, 0:2, 0:2] = torch.eye( cls.RotationType.dim).unsqueeze_(dim=0).expand( p.shape[0], cls.RotationType.dim, cls.RotationType.dim) result[:, 0:2, 2] = torch.mm( cls.RotationType.wedge(p.__class__([1.])), p.transpose(1, 0)).transpose_(1, 0) # Got homogeneous coordinates elif p.shape[1] == cls.dim: result[:, 0:2, 0:2] = \ p[:, 2].unsqueeze_(dim=1).unsqueeze_(dim=2) * \ torch.eye( cls.RotationType.dim).unsqueeze_(dim=0).repeat( p.shape[0], 1, 1) result[:, 0:2, 2] = torch.mm( cls.RotationType.wedge(p.__class__([1.])), p[:, 0:2].transpose_(1, 0)).transpose_(1, 0) # Got wrong dimension else: raise ValueError("p must have shape ({},), ({},), (N,{}) or (N,{})".format( cls.dim - 1, cls.dim, cls.dim - 1, cls.dim)) return result.squeeze_() @classmethod def vee(cls, Xi): if Xi.dim() < 3: Xi = Xi.unsqueeze(dim=0) if Xi.shape[1:3] != (cls.dim, cls.dim): raise ValueError("Xi must have shape ({},{}) or (N,{},{})".format( cls.dim, cls.dim, cls.dim, cls.dim)) xi = Xi.new_empty(Xi.shape[0], cls.dof) xi[:, 0:2] = Xi[:, 0:2, 2] xi[:, 2] = cls.RotationType.vee(Xi[:, 0:2, 0:2]) return xi.squeeze_() @classmethod def wedge(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "phi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) Xi = xi.new_zeros(xi.shape[0], cls.dim, cls.dim) Xi[:, 0:2, 0:2] = cls.RotationType.wedge(xi[:, 2]) Xi[:, 0:2, 2] = xi[:, 0:2] return Xi.squeeze_()

50.115226

589

0.629003

import torch from . import _base from . import utils from .so2 import SO2Matrix class SE2Matrix(_base.SEMatrixBase): dim = 3 dof = 3 RotationType = SO2Matrix def adjoint(self): rot_part = self.rot.as_matrix() if rot_part.dim() < 3: rot_part = rot_part.unsqueeze(dim=0) trans = self.trans if trans.dim() < 2: trans = trans.unsqueeze(dim=0) trans_part = trans.new_empty( trans.shape[0], trans.shape[1], 1) trans_part[:, 0, 0] = trans[:, 1] trans_part[:, 1, 0] = -trans[:, 0] bottom_row = trans.new_zeros(self.dof) bottom_row[-1] = 1. bottom_row = bottom_row.unsqueeze_(dim=0).unsqueeze_( dim=0).expand(trans.shape[0], 1, self.dof) return torch.cat([torch.cat([rot_part, trans_part], dim=2), bottom_row], dim=1).squeeze_() @classmethod def exp(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "xi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) rho = xi[:, 0:2] phi = xi[:, 2] rot = cls.RotationType.exp(phi) rot_jac = cls.RotationType.left_jacobian(phi) if rot_jac.dim() < 3: rot_jac.unsqueeze_(dim=0) if rho.dim() < 3: rho.unsqueeze_(dim=2) trans = torch.bmm(rot_jac, rho).squeeze_() return cls(rot, trans) @classmethod def inv_left_jacobian(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "xi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) rho = xi[:, 0:2] phi = xi[:, 2] cos_phi = torch.cos(phi) sin_phi = torch.sin(phi) phi_sq = phi * phi small_angle_mask = utils.isclose(phi_sq, 0.) small_angle_inds = small_angle_mask.nonzero().squeeze_(dim=1) large_angle_mask = small_angle_mask.logical_not() large_angle_inds = large_angle_mask.nonzero().squeeze_(dim=1) jac = torch.zeros((xi.shape[0], cls.dof, cls.dof)).to(xi.device) jac[small_angle_inds, 0, 0] = -(96*(phi_sq[small_angle_inds] - 6))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 0, 1] = -(24*phi[small_angle_inds]*(phi_sq[small_angle_inds] - 12))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 0, 2] = (4*(12*phi[small_angle_inds]*rho[small_angle_inds,0] - 72*rho[small_angle_inds,1] + 12*phi_sq[small_angle_inds]*rho[small_angle_inds,1] - 12*phi_sq[small_angle_inds]*rho[small_angle_inds,1] + phi_sq[small_angle_inds]*phi_sq[small_angle_inds]*rho[small_angle_inds,1] + phi_sq[small_angle_inds]*phi[small_angle_inds]*rho[small_angle_inds,0]))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 1, 0] = (24*phi[small_angle_inds]*(phi_sq[small_angle_inds] - 12))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 1, 1] = -(96*(phi_sq[small_angle_inds] - 6))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[small_angle_inds, 1, 2] = (4*(72*rho[small_angle_inds,0] - 12*phi_sq[small_angle_inds]*rho[small_angle_inds,0] + 12*phi[small_angle_inds]*rho[small_angle_inds,1] + 12*phi_sq[small_angle_inds]*rho[small_angle_inds,0] - phi_sq[small_angle_inds]*phi_sq[small_angle_inds]*rho[small_angle_inds,0] + phi_sq[small_angle_inds]*phi[small_angle_inds]*rho[small_angle_inds,1]))/(phi_sq[small_angle_inds]**2*phi_sq[small_angle_inds] + 16*phi_sq[small_angle_inds]**2 - 24*phi_sq[small_angle_inds]*phi_sq[small_angle_inds] - 192*phi_sq[small_angle_inds] + 144*phi_sq[small_angle_inds] + 576) jac[large_angle_inds, 0, 0] = (sin_phi[large_angle_inds]*phi[large_angle_inds])/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 0, 1] = -(phi[large_angle_inds]*(cos_phi[large_angle_inds] - 1))/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 0, 2] = (phi[large_angle_inds]*(rho[large_angle_inds,0] - 2*cos_phi[large_angle_inds]*rho[large_angle_inds,0] - phi[large_angle_inds]*rho[large_angle_inds,1] + cos_phi[large_angle_inds]**2*rho[large_angle_inds,0] + sin_phi[large_angle_inds]**2*rho[large_angle_inds,0] + cos_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,1] - sin_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,0]))/(phi_sq[large_angle_inds]*(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1)) jac[large_angle_inds, 1, 0] = (phi[large_angle_inds]*(cos_phi[large_angle_inds] - 1))/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 1, 1] = (sin_phi[large_angle_inds]*phi[large_angle_inds])/(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1) jac[large_angle_inds, 1, 2] = (phi[large_angle_inds]*(rho[large_angle_inds,1] - 2*cos_phi[large_angle_inds]*rho[large_angle_inds,1] + phi[large_angle_inds]*rho[large_angle_inds,0] + cos_phi[large_angle_inds]**2*rho[large_angle_inds,1] + sin_phi[large_angle_inds]**2*rho[large_angle_inds,1] - cos_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,0] - sin_phi[large_angle_inds]*phi[large_angle_inds]*rho[large_angle_inds,1]))/(phi_sq[large_angle_inds]*(cos_phi[large_angle_inds]**2 - 2*cos_phi[large_angle_inds] + sin_phi[large_angle_inds]**2 + 1)) jac[:, 2, 0] = 0 jac[:, 2, 1] = 0 jac[:, 2, 2] = 1 return jac.squeeze_() @classmethod def left_jacobian(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "xi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) rho = xi[:, 0:2] phi = xi[:, 2] cos_phi = torch.cos(phi) sin_phi = torch.sin(phi) phi_sq = phi * phi small_angle_mask = utils.isclose(phi_sq, 0.) small_angle_inds = small_angle_mask.nonzero().squeeze_(dim=1) large_angle_mask = small_angle_mask.logical_not() large_angle_inds = large_angle_mask.nonzero().squeeze_(dim=1) jac = torch.zeros((xi.shape[0], cls.dof, cls.dof)).to(xi.device) jac[small_angle_inds, 0, 0] = 1 - 1./6. * phi_sq[small_angle_inds] jac[small_angle_inds, 0, 1] = -(0.5 * phi[small_angle_inds] - 1./24. * phi[small_angle_inds] * phi_sq[small_angle_inds]) jac[small_angle_inds, 0, 2] = rho[small_angle_inds,1] / 2. + phi[small_angle_inds] * rho[small_angle_inds,0] / 6. jac[small_angle_inds, 1, 0] = 0.5 * phi[small_angle_inds] - 1./24. * phi[small_angle_inds] * phi_sq[small_angle_inds] jac[small_angle_inds, 1, 1] = 1 - 1./6. * phi_sq[small_angle_inds] jac[small_angle_inds, 1, 2] = -rho[small_angle_inds,0] / 2. + phi[small_angle_inds] * rho[small_angle_inds,1] / 6. jac[large_angle_inds, 0, 0] = sin_phi[large_angle_inds] / phi[large_angle_inds] jac[large_angle_inds, 0, 1] = -(1 - cos_phi[large_angle_inds]) / phi[large_angle_inds] jac[large_angle_inds, 0, 2] = ( rho[large_angle_inds,1] + phi[large_angle_inds]*rho[large_angle_inds,0] - rho[large_angle_inds,1]*cos_phi[large_angle_inds] - rho[large_angle_inds,0]*sin_phi[large_angle_inds])/phi_sq[large_angle_inds] jac[large_angle_inds, 1, 0] = (1 - cos_phi[large_angle_inds]) / phi[large_angle_inds] jac[large_angle_inds, 1, 1] = sin_phi[large_angle_inds] / phi[large_angle_inds] jac[large_angle_inds, 1, 2] = (-rho[large_angle_inds,0] + phi[large_angle_inds]*rho[large_angle_inds,1] + rho[large_angle_inds,0]*cos_phi[large_angle_inds] - rho[large_angle_inds,1]*sin_phi[large_angle_inds])/phi_sq[large_angle_inds] jac[:, 2, 0] = 0 jac[:, 2, 1] = 0 jac[:, 2, 2] = 1 return jac.squeeze_() def log(self): phi = self.rot.log() inv_rot_jac = self.RotationType.inv_left_jacobian(phi) if self.trans.dim() < 2: trans = self.trans.unsqueeze(dim=0) else: trans = self.trans if phi.dim() < 1: phi.unsqueeze_(dim=0) phi.unsqueeze_(dim=1) if inv_rot_jac.dim() < 3: inv_rot_jac.unsqueeze_(dim=0) if trans.dim() < 3: trans = trans.unsqueeze(dim=2) rho = torch.bmm(inv_rot_jac, trans).squeeze_() if rho.dim() < 2: rho.unsqueeze_(dim=0) return torch.cat([rho, phi], dim=1).squeeze_() @classmethod def odot(cls, p, directional=False): if p.dim() < 2: p = p.unsqueeze(dim=0) result = p.__class__(p.shape[0], p.shape[1], cls.dof).zero_() if p.shape[1] == cls.dim - 1: if not directional: result[:, 0:2, 0:2] = torch.eye( cls.RotationType.dim).unsqueeze_(dim=0).expand( p.shape[0], cls.RotationType.dim, cls.RotationType.dim) result[:, 0:2, 2] = torch.mm( cls.RotationType.wedge(p.__class__([1.])), p.transpose(1, 0)).transpose_(1, 0) elif p.shape[1] == cls.dim: result[:, 0:2, 0:2] = \ p[:, 2].unsqueeze_(dim=1).unsqueeze_(dim=2) * \ torch.eye( cls.RotationType.dim).unsqueeze_(dim=0).repeat( p.shape[0], 1, 1) result[:, 0:2, 2] = torch.mm( cls.RotationType.wedge(p.__class__([1.])), p[:, 0:2].transpose_(1, 0)).transpose_(1, 0) else: raise ValueError("p must have shape ({},), ({},), (N,{}) or (N,{})".format( cls.dim - 1, cls.dim, cls.dim - 1, cls.dim)) return result.squeeze_() @classmethod def vee(cls, Xi): if Xi.dim() < 3: Xi = Xi.unsqueeze(dim=0) if Xi.shape[1:3] != (cls.dim, cls.dim): raise ValueError("Xi must have shape ({},{}) or (N,{},{})".format( cls.dim, cls.dim, cls.dim, cls.dim)) xi = Xi.new_empty(Xi.shape[0], cls.dof) xi[:, 0:2] = Xi[:, 0:2, 2] xi[:, 2] = cls.RotationType.vee(Xi[:, 0:2, 0:2]) return xi.squeeze_() @classmethod def wedge(cls, xi): if xi.dim() < 2: xi = xi.unsqueeze(dim=0) if xi.shape[1] != cls.dof: raise ValueError( "phi must have shape ({},) or (N,{})".format(cls.dof, cls.dof)) Xi = xi.new_zeros(xi.shape[0], cls.dim, cls.dim) Xi[:, 0:2, 0:2] = cls.RotationType.wedge(xi[:, 2]) Xi[:, 0:2, 2] = xi[:, 0:2] return Xi.squeeze_()

true

f7130f24fd401c265e56739ce8f20b9a6ec678b3

2,570

py

Python

test/record/parser/test_response_whois_nic_net_ng_status_registered.py

huyphan/pyyawhois

77fb2f73a9c67989f1d41d98f37037406a69d136

[ "MIT" ]

null

test/record/parser/test_response_whois_nic_net_ng_status_registered.py

huyphan/pyyawhois

77fb2f73a9c67989f1d41d98f37037406a69d136

[ "MIT" ]

null

test/record/parser/test_response_whois_nic_net_ng_status_registered.py

huyphan/pyyawhois

77fb2f73a9c67989f1d41d98f37037406a69d136

[ "MIT" ]

null

# This file is autogenerated. Do not edit it manually. # If you want change the content of this file, edit # # spec/fixtures/responses/whois.nic.net.ng/status_registered # # and regenerate the tests with the following script # # $ scripts/generate_tests.py # from nose.tools import * from dateutil.parser import parse as time_parse import yawhois class TestWhoisNicNetNgStatusRegistered(object): def setUp(self): fixture_path = "spec/fixtures/responses/whois.nic.net.ng/status_registered.txt" host = "whois.nic.net.ng" part = yawhois.record.Part(open(fixture_path, "r").read(), host) self.record = yawhois.record.Record(None, [part]) def test_status(self): eq_(self.record.status, 'registered') def test_available(self): eq_(self.record.available, False) def test_domain(self): eq_(self.record.domain, "nic.net.ng") def test_nameservers(self): eq_(self.record.nameservers.__class__.__name__, 'list') eq_(len(self.record.nameservers), 4) eq_(self.record.nameservers[0].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[0].name, "rns1.nic.net.ng") eq_(self.record.nameservers[1].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[1].name, "rns2.nic.net.ng") eq_(self.record.nameservers[2].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[2].name, "rns3.nic.net.ng") eq_(self.record.nameservers[3].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[3].name, "rns4.nic.net.ng") def test_registered(self): eq_(self.record.registered, True) def test_created_on(self): eq_(self.record.created_on.__class__.__name__, 'datetime') eq_(self.record.created_on, time_parse('2009-05-13 14:27:27 UTC')) def test_registrar(self): eq_(self.record.registrar.__class__.__name__, 'Registrar') eq_(self.record.registrar.id, None) eq_(self.record.registrar.name, "nira") eq_(self.record.registrar.organization, None) eq_(self.record.registrar.url, None) def test_updated_on(self): eq_(self.record.updated_on.__class__.__name__, 'datetime') eq_(self.record.updated_on, time_parse('2012-08-24 13:46:14 UTC')) def test_domain_id(self): eq_(self.record.domain_id, "6808-NIRA") def test_expires_on(self): eq_(self.record.expires_on.__class__.__name__, 'datetime') eq_(self.record.expires_on, time_parse('2020-07-30 23:00:00 UTC'))

37.246377

87

0.682879

from nose.tools import * from dateutil.parser import parse as time_parse import yawhois class TestWhoisNicNetNgStatusRegistered(object): def setUp(self): fixture_path = "spec/fixtures/responses/whois.nic.net.ng/status_registered.txt" host = "whois.nic.net.ng" part = yawhois.record.Part(open(fixture_path, "r").read(), host) self.record = yawhois.record.Record(None, [part]) def test_status(self): eq_(self.record.status, 'registered') def test_available(self): eq_(self.record.available, False) def test_domain(self): eq_(self.record.domain, "nic.net.ng") def test_nameservers(self): eq_(self.record.nameservers.__class__.__name__, 'list') eq_(len(self.record.nameservers), 4) eq_(self.record.nameservers[0].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[0].name, "rns1.nic.net.ng") eq_(self.record.nameservers[1].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[1].name, "rns2.nic.net.ng") eq_(self.record.nameservers[2].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[2].name, "rns3.nic.net.ng") eq_(self.record.nameservers[3].__class__.__name__, 'Nameserver') eq_(self.record.nameservers[3].name, "rns4.nic.net.ng") def test_registered(self): eq_(self.record.registered, True) def test_created_on(self): eq_(self.record.created_on.__class__.__name__, 'datetime') eq_(self.record.created_on, time_parse('2009-05-13 14:27:27 UTC')) def test_registrar(self): eq_(self.record.registrar.__class__.__name__, 'Registrar') eq_(self.record.registrar.id, None) eq_(self.record.registrar.name, "nira") eq_(self.record.registrar.organization, None) eq_(self.record.registrar.url, None) def test_updated_on(self): eq_(self.record.updated_on.__class__.__name__, 'datetime') eq_(self.record.updated_on, time_parse('2012-08-24 13:46:14 UTC')) def test_domain_id(self): eq_(self.record.domain_id, "6808-NIRA") def test_expires_on(self): eq_(self.record.expires_on.__class__.__name__, 'datetime') eq_(self.record.expires_on, time_parse('2020-07-30 23:00:00 UTC'))

true

f713115af82b8a3380081f84bc46d6ef1f73dcd3

92,922

py

Python

haros/extractor.py

git-afsantos/ecore

39dc383741dc1d9ed33cb5dc41f94bd5ffd4d03d

[ "MIT" ]

null

haros/extractor.py

git-afsantos/ecore

39dc383741dc1d9ed33cb5dc41f94bd5ffd4d03d

[ "MIT" ]

null

haros/extractor.py

git-afsantos/ecore

39dc383741dc1d9ed33cb5dc41f94bd5ffd4d03d

[ "MIT" ]

null

#Copyright (c) 2017 Andre Santos # #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. ############################################################################### # Imports ############################################################################### from __future__ import unicode_literals from future import standard_library standard_library.install_aliases() from builtins import next from builtins import str from builtins import range from past.builtins import basestring from builtins import object from fnmatch import fnmatch import itertools import logging from operator import attrgetter import os import re import subprocess from urllib.request import urlopen from urllib.error import URLError import xml.etree.ElementTree as ET import yaml from bonsai.model import ( CodeGlobalScope, CodeReference, CodeFunctionCall, pretty_str ) from bonsai.cpp.model import ( CppEntity, CppFunctionCall, CppDefaultArgument, CppOperator, CppReference ) from bonsai.analysis import ( CodeQuery, resolve_reference, resolve_expression, get_control_depth, get_conditions, get_condition_paths, is_under_loop ) try: from bonsai.cpp.clang_parser import CppAstParser except ImportError: CppAstParser = None from bonsai.py.py_parser import PyAstParser from rospkg import RosPack, RosStack, ResourceNotFound from xml.etree.cElementTree import ElementTree from distutils.spawn import find_executable from .cmake_parser import RosCMakeParser from .launch_parser import LaunchParser, LaunchParserError from .metamodel import ( Project, Repository, Package, SourceFile, Node, Person, SourceCondition, AdvertiseCall, SubscribeCall, AdvertiseServiceCall, ServiceClientCall, Location, GetParamCall, SetParamCall ) from .util import cwd ############################################################################### # Utility ############################################################################### class LoggingObject(object): log = logging.getLogger(__name__) def findRosPackages(paths = None, as_stack = False): """ Find ROS packages inside folders. :param paths: [list] of [str] File system path to search, [None] to use the ROS default search paths. :param as_stack: [bool] Whether the paths point to stacks. :returns: [dict] Dictionary of [str]package_name -> [str]package_path. """ ros_version = os.environ.get("ROS_VERSION") if ros_version != "1": # try ROS2 crawling with colcon if possible # (in ambiguous cases, we give preference to trying the ROS2 method first, # because ROS1 rospkg only produces misleading/ # incorrect information when used in ROS2/mixed workspaces. colcon = find_executable('colcon') if colcon != None: cmd = [colcon, 'list'] if paths != None: cmd.extend(['--base-paths']) cmd.extend(paths) try: pkglist = subprocess.check_output(cmd) # format is <pkg_name>\t<pkg_path>\t<build_system>\n pkglist = pkglist.split('\n') pkgs = {} for pkginfo in pkglist: pkginfo_parts = pkginfo.split('\t') if len(pkginfo_parts) < 2: continue if pkginfo_parts[0] in pkgs: continue pkgs[pkginfo_parts[0]] = pkginfo_parts[1] return pkgs except: pass # ^ if colcon != None # ^ if ros_version != "1" # else: try the ROS1 way ros = None if as_stack: ros = RosStack.get_instance(paths) else: ros = RosPack.get_instance(paths) pkg_names = ros.list() pkgs = {} for pkg_name in pkg_names: if pkg_name in pkgs: continue pkgs[pkg_name] = ros.get_path(pkg_name) return pkgs # ^ findRosPackages(paths) _EMPTY_DICT = {} _EMPTY_LIST = () ############################################################################### # Source Extractor ############################################################################### class ProjectExtractor(LoggingObject): def __init__(self, index_file, env = None, pkg_cache = None, repo_cache = None, repo_path = None, distro_url = None, require_repos = False, parse_nodes = False, node_cache = None): self.log.debug("ProjectExtractor(%s, %s, %s)", index_file, repo_path, distro_url) self.index_file = index_file self.repo_path = repo_path self.distribution = distro_url self.require_repos = require_repos self.parse_nodes = parse_nodes self.environment = env if not env is None else {} self.package_cache = pkg_cache if not pkg_cache is None else {} self.repo_cache = repo_cache if not repo_cache is None else {} self.node_cache = node_cache if not node_cache is None else {} self.project = None self.packages = None self.missing = None self.repositories = None self.configurations = None self.node_specs = None self.rules = None self.analysis = None self._extra_packages = set() def index_source(self, settings=None): self.log.debug("ProjectExtractor.index_source()") self._setup() settings.update_analysis_preferences(self.analysis) self._load_user_repositories() self._find_local_packages() if self.missing and self.distribution: self._load_distro_repositories() self._find_local_packages() self._topological_sort() for name in self.missing: self.log.warning("Could not find package " + name) self._populate_packages_and_dependencies(settings=settings) self._update_node_cache() self._find_nodes(settings) self._update_nodes_from_specs() def _setup(self): try: with open(self.index_file, "r") as handle: data = yaml.safe_load(handle) except IOError as e: data = {} self.project = Project(data.get("project", "default")) self.repositories = data.get("repositories", {}) self.packages = set(data.get("packages") or list(findRosPackages(["."]))) self.missing = set(self.packages) self.configurations = data.get("configurations", {}) self.node_specs = data.get("nodes", {}) self.project.node_specs = self.node_specs self.rules = data.get("rules", {}) self.analysis = data.get("analysis", {}) for node_name in self.node_specs: if not "/" in node_name: raise ValueError("expected '<pkg>/<node>' in node specs") pkg, exe = node_name.split("/") self._extra_packages.add(pkg) self.missing.update(self._extra_packages) def _load_user_repositories(self): self.log.info("Looking up user provided repositories.") extractor = RepositoryExtractor() for name, data in self.repositories.items(): repo = self.repo_cache.get(name) if repo: self.project.repositories.append(repo) else: extractor.load_from_user(name, data, project = self.project) if self.repo_path: try: extractor.download(self.repo_path) except RepositoryCloneError as e: if self.require_repos: raise e else: self.log.warning("Could not download all repositories.") def _find_local_packages(self): self.log.info("Looking for packages locally.") cdir = os.path.abspath(".") alt_paths = [self.repo_path, cdir] if self.repo_path else [cdir] extractor = PackageExtractor(alt_paths = alt_paths) extractor.refresh_package_cache() found = [] for name in self.missing: analyse = name in self.packages pkg = self.package_cache.get(name) if pkg: self.project.packages.append(pkg) found.append(name) pkg._analyse = analyse else: pkg = extractor.find_package(name, project=self.project) if pkg: found.append(name) pkg._analyse = analyse self.missing.difference_update(found) def _load_distro_repositories(self): self.log.info("Looking up repositories from official distribution.") try: data = yaml.safe_load(urlopen(self.distribution).read())["repositories"] except URLError as e: self.log.warning("Could not download distribution data.") return extractor = RepositoryExtractor() extractor.load_needed_from_distro(data, self.missing, self.project) if self.repo_path: try: extractor.download(self.repo_path) except RepositoryCloneError as e: if self.require_repos: raise e else: self.log.warning("Could not download all repositories.") def _topological_sort(self): dependencies = {} pending = list(self.project.packages) for pkg in self.project.packages: pkg.topological_tier = -1 dependencies[pkg.id] = set(p for p in pkg.dependencies.packages if p in self.packages) tier = 1 emitted = [] while pending: next_pending = [] next_emitted = [] for pkg in pending: deps = dependencies[pkg.id] deps.difference_update(emitted) if deps: next_pending.append(pkg) else: pkg.topological_tier = tier next_emitted.append(pkg.name) if not next_emitted: # cyclic dependencies detected self.log.warning("Cyclic dependencies: %s", next_pending) for pkg in next_pending: pkg.topological_tier = tier next_pending = None pending = next_pending emitted = next_emitted tier += 1 self.project.packages.sort(key = attrgetter("topological_tier", "id")) def _populate_packages_and_dependencies(self, settings=None): found = set() extractor = PackageExtractor() extractor.packages = self.project.packages for pkg in self.project.packages: found.add(pkg.name) analysis_ignore = extractor._populate_package( pkg, ignored_globs=settings.ignored_globs) if settings is not None: settings.ignored_lines.update(analysis_ignore) deps = extractor._extra extractor._extra = [] while deps: pkg = deps.pop() assert pkg.name not in found pkg._analyse = False found.add(pkg.name) self.project.packages.append(pkg) analysis_ignore = extractor._populate_package( pkg, ignored_globs=settings.ignored_globs) if settings is not None: settings.ignored_lines.update(analysis_ignore) deps.extend(extractor._extra) extractor._extra = [] def _find_nodes(self, settings): pkgs = {pkg.name: pkg for pkg in self.project.packages if pkg._analyse} ws = settings.workspace if not ws: ws = settings.find_ros_workspace() ws = os.path.abspath(ws) if CppAstParser is None: self.log.warning("C++ AST parser not found.") extractor = NodeExtractor(pkgs, self.environment, ws = ws, node_cache = self.node_cache, parse_nodes = self.parse_nodes) if self.parse_nodes and CppAstParser is not None: if settings is None: CppAstParser.set_library_path() db_dir = os.path.join(extractor.workspace, "build") if os.path.isfile( os.path.join(db_dir, "compile_commands.json")): CppAstParser.set_database(db_dir) else: #library file if given explicitly, otherwise path if settings.cpp_parser_lib_file: CppAstParser.set_library_file(settings.cpp_parser_lib_file) else: CppAstParser.set_library_path(settings.cpp_parser_lib) CppAstParser.set_standard_includes(settings.cpp_includes) db_dir = settings.cpp_compile_db if db_dir and os.path.isfile( os.path.join(db_dir, "compile_commands.json")): CppAstParser.set_database(settings.cpp_compile_db) for pkg in self.project.packages: if pkg._analyse and pkg.name not in self.package_cache: extractor.find_nodes(pkg) def _update_node_cache(self): self.log.debug("Importing cached Nodes.") data = [datum for datum in self.node_cache.values()] self.node_cache = {} empty_dict = {} empty_list = () for datum in data: try: pkg = self._get_package(datum["package"]) source_files = self._get_files(pkg, datum["files"]) except ValueError as e: # either a package or a file is no longer part of the analysis self.log.debug("Cached node %s: %s", datum["name"], e) continue mtime = datum["timestamp"] for sf in source_files: if sf.timestamp > mtime: # a file was modified, needs to be parsed again break else: node = Node(datum["name"], pkg, rosname = datum["rosname"], nodelet = datum["nodelet"]) node.source_files = source_files for p in datum["advertise"]: node.advertise.append(self._pub_from_JSON(p)) for p in datum["subscribe"]: node.subscribe.append(self._sub_from_JSON(p)) for p in datum["service"]: node.service.append(self._srv_from_JSON(p)) for p in datum["client"]: node.client.append(self._client_from_JSON(p)) for p in datum["readParam"]: node.read_param.append(self._read_from_JSON(p)) for p in datum["writeParam"]: node.write_param.append(self._write_from_JSON(p)) hpl = datum.get("hpl", empty_dict) for p in hpl.get("properties", empty_list): node.hpl_properties.append(p) for a in hpl.get("assumptions", empty_list): node.hpl_assumptions.append(a) self.node_cache[node.node_name] = node def _update_nodes_from_specs(self): self.log.debug("Loading Nodes from specs.") pkg_finder = PackageExtractor() pkg_finder.packages.extend(self.project.packages) nhm = NodeHints2(self.node_specs, pkg_finder=pkg_finder) # nodes = dict(self.node_cache) for pkg in self.project.packages: for node in pkg.nodes: node_type = node.node_name if node_type not in self.node_cache: self.log.debug( "WARNING node %s is not in node cache!", node_type) self.node_cache[node_type] = node new_nodes = nhm.apply_to(self.node_cache, create=True) for node in new_nodes: assert node.node_name not in self.node_cache self.node_cache[node.node_name] = node node.package.nodes.append(node) def _get_package(self, name): for pkg in self.project.packages: if pkg.name == name: return pkg raise ValueError("cannot find package: " + name) def _get_files(self, pkg, filenames): files = [] for filename in filenames: found = False for sf in pkg.source_files: if sf.full_name == filename: found = True files.append(sf) break if not found: raise ValueError("cannot find file: " + filename) return files def _pub_from_JSON(self, datum): l = self._location_from_JSON cs = [SourceCondition(c["condition"], location=l(c["location"]), statement=c["statement"]) for c in datum["conditions"]] return AdvertiseCall(datum["name"], datum["namespace"], datum["type"], datum["queue"], latched=datum.get("latched", False), control_depth = datum["depth"], repeats = datum["repeats"], conditions = cs, location = l(datum["location"])) def _sub_from_JSON(self, datum): l = self._location_from_JSON cs = [SourceCondition(c["condition"], location=l(c["location"]), statement=c["statement"]) for c in datum["conditions"]] return SubscribeCall(datum["name"], datum["namespace"], datum["type"], datum["queue"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = cs, location = l(datum["location"])) def _srv_from_JSON(self, datum): l = self._location_from_JSON cs = [SourceCondition(c["condition"], location=l(c["location"]), statement=c["statement"]) for c in datum["conditions"]] return AdvertiseServiceCall(datum["name"], datum["namespace"], datum["type"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = cs, location = l(datum["location"])) def _client_from_JSON(self, datum): l = self._location_from_JSON cs = [SourceCondition(c["condition"], location=l(c["location"]), statement=c["statement"]) for c in datum["conditions"]] return ServiceClientCall(datum["name"], datum["namespace"], datum["type"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = cs, location = l(datum["location"])) def _read_from_JSON(self, datum): l = self._location_from_JSON cs = [SourceCondition(c["condition"], location=l(c["location"]), statement=c["statement"]) for c in datum["conditions"]] return GetParamCall(datum["name"], datum["namespace"], datum["type"], default_value=datum["default_value"], control_depth=datum["depth"], repeats=datum["repeats"], conditions=cs, location=l(datum["location"])) def _write_from_JSON(self, datum): l = self._location_from_JSON cs = [SourceCondition(c["condition"], location=l(c["location"]), statement=c["statement"]) for c in datum["conditions"]] return SetParamCall(datum["name"], datum["namespace"], datum["type"], value=datum["value"], control_depth=datum["depth"], repeats=datum["repeats"], conditions=cs, location=l(datum["location"])) def _location_from_JSON(self, datum): if datum is None: return None try: pkg = self._get_package(datum["package"]) sf = None filename = datum["file"] if filename: sf = self._get_files(pkg, [filename])[0] except ValueError: return None return Location(pkg, file=sf, line=datum["line"], col=datum["column"], fun=datum["function"], cls=datum["class"]) ############################################################################### # Repository Extractor ############################################################################### class RepositoryCloneError(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value) class RepositoryExtractor(LoggingObject): def __init__(self): self.repositories = [] self.declared_packages = set() def load_from_user(self, name, data, project = None): self.log.debug("RepositoryExtractor.from_user(%s, %s)", name, data) repo = Repository(name, proj = project) repo.status = "private" repo.vcs = data["type"] repo.url = data["url"] repo.version = data["version"] repo.declared_packages = data["packages"] self.repositories.append(repo) self.declared_packages.update(repo.declared_packages) if project: project.repositories.append(repo) return repo def load_from_distro(self, name, data, project = None): self.log.debug("RepositoryExtractor.from_distro(%s, %s)", name, data) if not "source" in data: self.log.debug("There is no source in provided data.") return repo = Repository(name, proj = project) repo.status = data.get("status") src = data["source"] repo.vcs = src["type"] repo.url = src["url"] repo.version = src["version"] if "release" in data: repo.declared_packages = data["release"].get("packages", [name]) self.repositories.append(repo) self.declared_packages.update(repo.declared_packages) if project: project.repositories.append(repo) return repo def load_needed_from_distro(self, data, pkgs, project = None): if not pkgs: return True remaining = set(pkgs) for name, info in data.items(): if not "release" in info: continue for pkg in info["release"].get("packages", [name]): try: remaining.remove(pkg) self.load_from_distro(name, info, project = project) except KeyError as e: pass if not remaining: break return not remaining def download(self, repo_path): self.log.debug("RepositoryExtractor.download(%s)", repo_path) for repo in self.repositories: if not repo.url: self.log.debug("%s has no URL to download from.", repo.id) continue path = os.path.join(repo_path, repo.name) clone = False if not os.path.exists(path): os.makedirs(path) clone = True with cwd(path): if repo.vcs == "git": self._download_git(repo, path, clone) elif repo.vcs == "hg": self._download_hg(repo, path, clone) elif repo.vcs == "svn": self._download_svn(repo, path, clone) return True GIT_INIT = ("git", "init") GIT_PULL = ("git", "pull") GIT_COUNT = ("git", "rev-list", "HEAD", "--count") def _download_git(self, repo, path, clone = False): self.log.debug("RepositoryExtractor._download_git(%s)", path) try: if clone: subprocess.check_call(self.GIT_INIT) subprocess.check_call(["git", "remote", "add", "-t", repo.version, "-f", "origin", repo.url]) subprocess.check_call(["git", "checkout", repo.version]) else: subprocess.check_call(self.GIT_PULL) repo.path = path repo.commits = int(subprocess.check_output(self.GIT_COUNT).rstrip()) except subprocess.CalledProcessError as e: raise RepositoryCloneError("git error: " + str(e)) HG_PULL = ("hg", "pull") HG_COUNT = ("hg", "id", "--num", "--rev", "tip") def _download_hg(self, repo, path, clone = False): self.log.debug("RepositoryExtractor._download_hg(%s)", path) try: if clone: subprocess.check_call(["hg", "clone", repo.url, "-r", repo.version]) else: subprocess.check_call(self.HG_PULL) repo.path = path repo.commits = int(subprocess.check_output(self.HG_COUNT).rstrip()) except subprocess.CalledProcessError as e: raise RepositoryCloneError("hg error: " + str(e)) SVN_FETCH = ("git", "svn", "fetch") def _download_svn(self, repo, path, clone = False): self.log.debug("RepositoryExtractor._download_svn(%s)", path) try: if clone: if repo.version == "trunk": version = repo.version else: version = "branches/" + repo.version subprocess.check_call(["git", "svn", "clone", "-T", version, repo.url]) else: subprocess.check_call(self.SVN_FETCH) self.path = path self.commits = int(subprocess.check_output(self.GIT_COUNT).rstrip()) except subprocess.CalledProcessError as e: raise RepositoryCloneError("git-svn error: " + str(e)) ############################################################################### # Package Extractor ############################################################################### class PackageExtractor(LoggingObject): def __init__(self, alt_paths = None): self.packages = [] self.rospack_pkgs = None self.rosstack_pkgs = None self.alt_paths = alt_paths self.altpack_pkgs = None self.altstack_pkgs = None self._pkg_cache = {} self._extra = [] def refresh_package_cache(self): self.rospack_pkgs = None self.rosstack_pkgs = None self.altpack_pkgs = None self.altstack_pkgs = None # To use with LaunchParser. def get(self, pkg_id, populate=True): self.log.debug("%s.get('%s')", type(self).__name__, pkg_id) if pkg_id in self._pkg_cache: return self._pkg_cache[pkg_id] for pkg in self.packages: if pkg.id == pkg_id: self._pkg_cache[pkg_id] = pkg return pkg try: assert pkg_id.startswith("package:") pkg = self._find(pkg_id[8:], None) self._pkg_cache[pkg_id] = pkg self._extra.append(pkg) pkg._analyse = False if populate: self._populate_package(pkg) except (IOError, ET.ParseError, ResourceNotFound): return None return pkg def find_package(self, name, project=None, analyse=True): try: pkg = self._find(name, project) pkg._analyse = analyse self.packages.append(pkg) if project: project.packages.append(pkg) for repo in project.repositories: if name in repo.declared_packages: pkg.repository = repo repo.packages.append(pkg) break # self._populate_package(pkg) except (IOError, ET.ParseError, KeyError): return None return pkg def find_package_at(self, dirpath, populate=True): try: manifest = os.path.join(dirpath, "package.xml") pkg = PackageParser.parse(manifest) if pkg.id in self._pkg_cache: return self._pkg_cache[pkg.id] else: self._pkg_cache[pkg.id] = pkg if pkg not in self._extra: self._extra.append(pkg) pkg._analyse = False if populate: self._populate_package(pkg) except (IOError, ET.ParseError, KeyError): return None return pkg def _find(self, name, project): path = None if self.alt_paths: if self.altpack_pkgs == None: self.altpack_pkgs = findRosPackages(paths=self.alt_paths, as_stack=False) path = self.altpack_pkgs.get(name, None) if (path == None): if self.altstack_pkgs == None: self.altstack_pkgs = findRosPackages(paths=self.alt_paths, as_stack=True) path = self.altstack_pkgs.get(name, None) if path is None: if self.rospack_pkgs == None: self.rospack_pkgs = findRosPackages(as_stack=False) path = self.rospack_pkgs.get(name, None) if path is None: if self.rosstack_pkgs == None: self.rosstack_pkgs = findRosPackages(as_stack=True) path = self.rosstack_pkgs.get(name, None) if path is None: raise KeyError(name) return PackageParser.parse(os.path.join(path, "package.xml"), project = project) EXCLUDED = (".git", "doc", "cmake", ".eggs", "__pycache__") _START_GLOB = (os.path.sep, '*', '?', '[') _BYTE_CODE = (".pyc", ".pyd", ".pyo") def _populate_package(self, pkg, ignored_globs=None): self.log.debug("PackageExtractor.populate(%s, %s)", pkg, ignored_globs) if not pkg.path: self.log.debug("Package %s has no path", pkg.name) return self.log.info("Indexing source files for package %s", pkg.name) analysis_ignore = {} #pkgs = {pkg.id: pkg for pkg in self.packages} launch_parser = LaunchParser(pkgs=self) prefix = len(pkg.path) + len(os.path.sep) if ignored_globs is None: ignored_globs = () else: ignored_globs = list(ignored_globs) for i in range(len(ignored_globs)): c = ignored_globs[i][0] if not c in self._START_GLOB: ignored_globs[i] = '*/' + ignored_globs[i] for root, subdirs, files in os.walk(pkg.path, topdown=True): if 'COLCON_IGNORE' in files or 'AMENT_IGNORE' in files or 'CATKIN_IGNORE' in files: del subdirs[:] # don't traverse into subdirectories continue # skip subdirs[:] = [d for d in subdirs if d not in self.EXCLUDED] path = root[prefix:] for filename in files: self.log.debug("Found file %s at %s", filename, path) source = SourceFile(filename, path, pkg) self.log.debug("File language: %s", source.language) sfn = os.path.join(pkg.name, source.full_name) if source.language == "unknown": if filename.endswith(self._BYTE_CODE): self.log.debug("Python bytecode file %s was ignored", sfn) continue # skip this file if any(fnmatch(sfn, pattern) for pattern in ignored_globs): self.log.debug( "File %s was ignored due to glob pattern", sfn) continue # skip this file ignore = source.set_file_stats() if any(v for v in ignore.values()): analysis_ignore[source.id] = ignore if pkg._analyse and source.language == "launch": self.log.info("Parsing launch file: " + source.path) try: source.tree = launch_parser.parse(source.path) except LaunchParserError as e: self.log.warning("Parsing error in %s:\n%s", source.path, str(e)) pkg.source_files.append(source) pkg.size += source.size pkg.lines += source.lines pkg.sloc += source.sloc return analysis_ignore ############################################################################### # Package Parser ############################################################################### class PackageParser(LoggingObject): @staticmethod def parse(pkg_file, project = None): PackageParser.log.debug("PkgParser.parse(%s, %s)", pkg_file, project) with open(pkg_file, "r") as handle: root = ET.parse(handle).getroot() name = root.find("name").text.strip() package = Package(name, proj = project) package.path = os.path.dirname(pkg_file) PackageParser.log.info("Found package %s at %s", package, package.path) PackageParser._parse_metadata(root, package) PackageParser._parse_export(root, package) PackageParser._parse_dependencies(root, package) return package @staticmethod def _parse_metadata(xml, package): package.description = (xml.find("description").text or "").strip() for el in xml.findall("maintainer"): name = (el.text or "?").strip() email = el.get("email") or "email@example.com" package.maintainers.add(Person(name, email)) for el in xml.findall("author"): name = (el.text or "?").strip() email = el.get("email") or "email@example.com" package.authors.add(Person(name, email)) for el in xml.findall("license"): package.licenses.add((el.text or "?").strip()) for el in xml.findall("url"): value = el.get("type") if value is None or value == "website": if el.text: package.website = el.text.strip() elif value == "repository": if el.text: package.vcs_url = el.text.strip() elif value == "bugtracker": if el.text: package.bug_url = el.text.strip() el = xml.find("version") if el is not None: package.version = (el.text or "?").strip() @staticmethod def _parse_export(xml, package): el = xml.find("export") if not el is None: package.is_metapackage = not el.find("metapackage") is None if not el.find("nodelet") is None: nodelets = el.find("nodelet").get("plugin") nodelets = nodelets.replace("${prefix}", package.path) with open(nodelets, "r") as handle: xmltext = "<export>{}</export>".format(handle.read()) root = ET.fromstring(xmltext) PackageParser.log.info("Found nodelets at %s", nodelets) libs = [] for child in root: if child.tag == "library": libs.append(child) else: libs.extend(child.findall("library")) for el in libs: libname = el.get("path").rsplit(os.sep)[-1] for cl in el.findall("class"): nodelet = cl.get("type").split("::")[-1] node = Node(libname, package, nodelet = nodelet) package.nodes.append(node) @staticmethod def _parse_dependencies(xml, package): sources = ["build_depend"] if xml.get("format") == "2": sources.extend(("depend", "build_export_depend", "exec_depend")) else: sources.append("run_depend") for src in sources: for el in xml.findall(src): name = el.text.strip() if name: package.dependencies.packages.add(name) ############################################################################### # Hard-coded Node Parser ############################################################################### class HardcodedNodeParser(LoggingObject): model_dir = None distro = None _cache = {} @classmethod def get(cls, pkg, node_type): cls.log.debug("Fetching hard-coded node: (%s, %s, %s)", pkg, node_type, cls.distro) node_id = "node:" + pkg + "/" + node_type if node_id in cls._cache: cls.log.debug("Node already in cache.") return cls._cache[node_id] filename = os.path.join(cls.model_dir, pkg + ".yaml") try: with open(filename) as handle: data = yaml.safe_load(handle) except IOError as e: cls.log.debug("YAML file not found: %s", filename) return None if not cls.distro in data: cls.log.debug("Package has no data for ROS %s.", cls.distro) return None if not node_type in data[cls.distro]: cls.log.debug("Node does not exist for ROS %s.", cls.distro) return None cls.log.debug("Building node from YAML data.") pkg = Package(pkg) pkg.path = "/tmp/" + pkg.name node = cls._build_node(node_type, cls.distro, pkg, data) cls._cache[node_id] = node return node @classmethod def _build_node(cls, node_type, distro, pkg, data): node_data = data[distro][node_type] base = node_data.get("base") if base: node = cls._build_node(node_type, base, pkg, data) else: node = Node(node_type, pkg, rosname = node_data.get("rosname"), nodelet = node_type if node_data["nodelet"] else None) for datum in node_data.get("advertise", ()): loc = cls._loc(pkg, datum) pub = AdvertiseCall(datum["name"], datum["namespace"], datum["type"], datum["queue"], latched=datum.get("latched", False), control_depth=datum["depth"], repeats=datum["repeats"], conditions=[SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.advertise.append(pub) for datum in node_data.get("subscribe", ()): loc = cls._loc(pkg, datum) sub = SubscribeCall(datum["name"], datum["namespace"], datum["type"], datum["queue"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = [SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.subscribe.append(sub) for datum in node_data.get("service", ()): loc = cls._loc(pkg, datum) srv = AdvertiseServiceCall(datum["name"], datum["namespace"], datum["type"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = [SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.service.append(srv) for datum in node_data.get("client", ()): loc = cls._loc(pkg, datum) cli = ServiceClientCall(datum["name"], datum["namespace"], datum["type"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = [SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.client.append(cli) for datum in node_data.get("readParam", ()): loc = cls._loc(pkg, datum) par = GetParamCall(datum["name"], datum["namespace"], datum["type"], default_value=datum.get("default"), control_depth=datum["depth"], repeats=datum["repeats"], conditions=[SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.read_param.append(par) for datum in node_data.get("writeParam", ()): loc = cls._loc(pkg, datum) par = SetParamCall(datum["name"], datum["namespace"], datum["type"], value=datum.get("value"), control_depth=datum["depth"], repeats=datum["repeats"], conditions=[SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.write_param.append(par) cls.log.debug("Hard-coded Node: " + str(node.to_JSON_object())) return node @classmethod def _loc(cls, pkg, data): loc = data.get("location") if loc is None: return None p = loc.get("package") if p is None or p != pkg.name: return None f = loc["file"] for sf in pkg.source_files: if sf.full_name == f: f = sf break else: parts = loc["file"].rsplit("/", 1) if len(parts) == 1: directory = "" name = parts[0] else: assert len(parts) == 2 directory, name = parts f = SourceFile(name, directory, pkg) pkg.source_files.append(f) return Location(pkg, file=f, line=loc["line"], col=loc["column"], fun=loc.get("function"), cls=loc.get("class")) ############################################################################### # Node Extractor ############################################################################### class NodeExtractor(LoggingObject): def __init__(self, pkgs, env, ws=None, node_cache=None, parse_nodes=False): self.package = None self.packages = pkgs self.environment = env self.workspace = ws self.node_cache = node_cache self.parse_nodes = parse_nodes self.nodes = [] self.roscpp_extractor = None self.rospy_extractor = None def find_nodes(self, pkg): self.log.debug("NodeExtractor.find_nodes(%s)", pkg) self.package = pkg srcdir = self.package.path[len(self.workspace):] srcdir = os.path.join(self.workspace, srcdir.split(os.sep, 1)[0]) bindir = os.path.join(self.workspace, "build") cmake_path = os.path.join(self.package.path, "CMakeLists.txt") if os.path.isfile(cmake_path): parser = RosCMakeParser(srcdir, bindir, pkgs = self.packages, env = self.environment, vars = self._default_variables()) parser.parse(cmake_path) self._update_nodelets(parser.libraries) self._register_nodes(parser.executables) else: # It may be normal for pure Python projects not to have a CMakeLists.txt # Instead, search for python files with "def main():" pattern = re.compile('^def\s+main\s*$.*$\s*:') for file in pkg.source_files: if file.language != 'python': continue # continue with next file entry_point_found = False with open(file.path) as f: for line in f: match = pattern.match(line) if match is not None: entry_point_found = True break if entry_point_found == False: continue # continue with next file # else: this is a python file with a 'main' function, # so we consider it a node. node = Node(file.full_name, pkg) node.source_files.append(file) self.nodes.append(node) self.package.nodes.append(node) if self.parse_nodes: self._extract_primitives() def _default_variables(self): # TODO: clean up these hardcoded values v = {} v["catkin_INCLUDE_DIRS"] = os.path.join(self.workspace, "devel/include") v["Boost_INCLUDE_DIRS"] = "/usr/include/" v["Eigen_INCLUDE_DIRS"] = "/usr/include/eigen3" v["ImageMagick_INCLUDE_DIRS"] = "/usr/include/ImageMagick" v["PROJECT_SOURCE_DIR"] = self.package.path return v def _get_file(self, path): for sf in self.package.source_files: if sf.path == path: return sf return None def _update_nodelets(self, libraries): lib_files = {} for target in libraries.values(): files = [] for path in target.files: sf = self._get_file(path) if sf: files.append(sf) for link in target.links: for path in link.files: sf = self._get_file(path) if sf: files.append(sf) lib_files[target.prefixed_name] = files for nodelet in self.package.nodes: if not nodelet.is_nodelet: continue if nodelet.name in lib_files: nodelet.source_files = lib_files[nodelet.name] def _register_nodes(self, executables): for target in executables.values(): node = Node(target.output_name, self.package) for path in target.files: sf = self._get_file(path) if sf: node.source_files.append(sf) for link in target.links: for path in link.files: sf = self._get_file(path) if sf: node.source_files.append(sf) lang = node.language if lang == "cpp" or lang == "python": self.log.debug("register %s node: %s", lang, node.node_name) self.nodes.append(node) self.package.nodes.append(node) else: self.log.debug("CMake target is not a node: %s (%s) %s", node.node_name, lang, node.source_files) def _extract_primitives(self, force_when_cached=False): self.roscpp_extractor = RoscppExtractor(self.package, self.workspace) self.rospy_extractor = RospyExtractor(self.package, self.workspace) for i in range(len(self.package.nodes)): node = self.package.nodes[i] self.log.debug("Extracting primitives for node %s", node.id) if node.source_tree is not None: self.log.debug("Node already has a source tree. Skipped.") continue if (node.node_name in self.node_cache) and not force_when_cached: self.log.debug("Using Node %s from cache.", node.node_name) node = self.node_cache[node.node_name] assert node.package is self.package self.package.nodes[i] = node continue node.source_tree = CodeGlobalScope() node.advertise = [] node.subscribe = [] node.service = [] node.client = [] node.read_param = [] node.write_param = [] if not node.source_files: self.log.warning("no source files for node " + node.id) if node.language == "cpp" and CppAstParser is not None: self.roscpp_extractor.extract(node) elif node.language == "python": self.rospy_extractor.extract(node) else: self.log.debug("Node written in %s.", node.language) self.log.debug("Skipping parsing and primitive extraction.") ############################################################################### # C++ Primitive Extractor ############################################################################### class RoscppExtractor(LoggingObject): def __init__(self, package, workspace): self.package = package self.workspace = workspace def extract(self, node): self.log.debug("Parsing C++ files for node %s", node.id) parser = CppAstParser(workspace=self.workspace, logger=__name__) for sf in node.source_files: self.log.debug("Parsing C++ file %s", sf.path) if parser.parse(sf.path) is None: self.log.warning("no compile commands for " + sf.path) node.source_tree = parser.global_scope # ----- queries after parsing, since global scope is reused ----------- self._query_comm_primitives(node, parser.global_scope) self._query_nh_param_primitives(node, parser.global_scope) self._query_param_primitives(node, parser.global_scope) def _query_comm_primitives(self, node, gs): for call in CodeQuery(gs).all_calls.where_name("advertise").get(): if call.canonical_type != "ros::Publisher": continue self._on_publication(node, self._resolve_node_handle(call.method_of), call) for call in CodeQuery(gs).all_calls.where_name("subscribe").get(): if call.canonical_type != "ros::Subscriber": continue self._on_subscription(node, self._resolve_node_handle(call.method_of), call) for call in CodeQuery(gs).all_calls.where_name("advertiseService").get(): if call.canonical_type != "ros::ServiceServer": continue self._on_service(node, self._resolve_node_handle(call.method_of), call) for call in CodeQuery(gs).all_calls.where_name("serviceClient").get(): if call.canonical_type != "ros::ServiceClient": continue self._on_client(node, self._resolve_node_handle(call.method_of), call) self.log.debug("Looking for image_transport::SubscriberFilter calls.") for call in CodeQuery(gs).all_calls.where_name("SubscriberFilter").get(): self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) if isinstance(call.reference, str): if not call.reference.startswith("c:@N@image_transport@S@SubscriberFilter"): continue if not "image_transport::SubscriberFilter" in call.canonical_type: continue n = call.arguments[0] if call.arguments else None self._on_subscription(node, self._resolve_it_node_handle(n), call, topic_pos = 1, queue_pos = 2, msg_type = "sensor_msgs/Image") self.log.debug("Looking for message_filters::Subscriber calls.") for call in CodeQuery(gs).all_calls.where_name("Subscriber").get(): self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) if isinstance(call.reference, str): if not call.reference.startswith("c:@N@message_filters@S@Subscriber"): continue if not "message_filters::Subscriber" in call.canonical_type: continue n = call.arguments[0] if call.arguments else None self._on_subscription(node, self._resolve_node_handle(n), call, topic_pos = 1, queue_pos = 2) self.log.debug("Looking for image_transport::Subscriber calls.") for call in CodeQuery(gs).all_calls.where_name("subscribe").get(): if call.canonical_type != "image_transport::Subscriber": continue self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) n = call.method_of if call.method_of else None self._on_subscription(node, self._resolve_it_node_handle(n), call, msg_type = "sensor_msgs/Image") self.log.debug("Looking for image_transport::Publisher.") for call in CodeQuery(gs).all_calls.where_name("advertise").get(): if call.canonical_type != "image_transport::Publisher": continue self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) n = call.method_of if call.method_of else None self._on_publication(node, self._resolve_it_node_handle(n), call, msg_type = "sensor_msgs/Image") def _query_nh_param_primitives(self, node, gs): nh_prefix = "c:@N@ros@S@NodeHandle@" gets = ("getParam", "getParamCached", "param") reads = gets + ("hasParam", "searchParam") for call in CodeQuery(gs).all_calls.where_name(reads).get(): if (call.full_name.startswith("ros::NodeHandle") or (isinstance(call.reference, str) and call.reference.startswith(nh_prefix))): param_type = default_value = None if call.name in gets: param_type = self._extract_param_type(call.arguments[1]) if call.name == "param": if len(call.arguments) > 2: default_value = self._extract_param_value( call, arg_pos=2) elif len(call.arguments) == 2: default_value = self._extract_param_value( call, arg_pos=1) self._on_read_param(node, self._resolve_node_handle(call), call, param_type, default_value) sets = ("setParam",) writes = sets + ("deleteParam",) for call in CodeQuery(gs).all_calls.where_name(writes).get(): if (call.full_name.startswith("ros::NodeHandle") or (isinstance(call.reference, str) and call.reference.startswith(nh_prefix))): param_type = value = None if len(call.arguments) >= 2 and call.name in sets: param_type = self._extract_param_type(call.arguments[1]) value = self._extract_param_value(call, arg_pos=1) self._on_write_param(node, self._resolve_node_handle(call), call, param_type, value) def _query_param_primitives(self, node, gs): ros_prefix = "c:@N@ros@N@param@" gets = ("get", "getCached", "param") reads = gets + ("has",) for call in CodeQuery(gs).all_calls.where_name(reads).get(): if (call.full_name.startswith("ros::param") or (isinstance(call.reference, str) and call.reference.startswith(ros_prefix))): param_type = default_value = None if call.name in gets: param_type = self._extract_param_type(call.arguments[1]) if call.name == "param": if len(call.arguments) > 2: default_value = self._extract_param_value( call, arg_pos=2) elif len(call.arguments) == 2: default_value = self._extract_param_value( call, arg_pos=1) self._on_read_param(node, "", call, param_type, default_value) for call in (CodeQuery(gs).all_calls.where_name("search") .where_result("bool").get()): if (call.full_name.startswith("ros::param") or (isinstance(call.reference, str) and call.reference.startswith(ros_prefix))): if len(call.arguments) > 2: ns = resolve_expression(call.arguments[0]) if not isinstance(ns, basestring): ns = "?" else: ns = "~" self._on_read_param(node, ns, call, None, None) sets = ("set",) writes = sets + ("del",) for call in CodeQuery(gs).all_calls.where_name(writes).get(): if (call.full_name.startswith("ros::param") or (isinstance(call.reference, str) and call.reference.startswith(ros_prefix))): param_type = value = None if len(call.arguments) >= 2 and call.name in sets: param_type = self._extract_param_type(call.arguments[1]) value = self._extract_param_value(call, arg_pos=1) self._on_write_param(node, "", call, param_type, value) def _on_publication(self, node, ns, call, topic_pos=0, queue_pos=1, msg_type=None, latch_pos=-1): if len(call.arguments) <= 1: return name = self._extract_topic(call, topic_pos=topic_pos) msg_type = msg_type or self._extract_message_type(call) queue_size = self._extract_queue_size(call, queue_pos=queue_pos) latched = False if len(call.arguments) >= 3 and len(call.arguments) > latch_pos: latched = self._extract_latch(call, latch_pos) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME pub = AdvertiseCall(name, ns, msg_type, queue_size, latched=latched, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.advertise.append(pub) self.log.debug("Found AdvertiseCall on %s/%s (%s)", ns, name, msg_type) def _on_subscription(self, node, ns, call, topic_pos=0, queue_pos=1, msg_type=None): if len(call.arguments) <= 1: return name = self._extract_topic(call, topic_pos=topic_pos) msg_type = msg_type or self._extract_message_type(call) queue_size = self._extract_queue_size(call, queue_pos=queue_pos) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME sub = SubscribeCall(name, ns, msg_type, queue_size, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.subscribe.append(sub) self.log.debug("Found SubscribeCall on %s/%s (%s)", ns, name, msg_type) def _on_service(self, node, ns, call): if len(call.arguments) <= 1: return name = self._extract_topic(call) msg_type = self._extract_message_type(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME srv = AdvertiseServiceCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.service.append(srv) self.log.debug("Found Service on %s/%s (%s)", ns, name, msg_type) def _on_client(self, node, ns, call): if len(call.arguments) <= 1: return name = self._extract_topic(call) msg_type = self._extract_message_type(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME cli = ServiceClientCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.client.append(cli) self.log.debug("Found Client on %s/%s (%s)", ns, name, msg_type) def _on_read_param(self, node, ns, call, param_type, default_value): if len(call.arguments) < 1: return name = self._extract_topic(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME read = GetParamCall(name, ns, param_type, default_value=default_value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive = True)) node.read_param.append(read) self.log.debug("Found Read on %s/%s (%s) (%s)", ns, name, param_type, default_value) def _on_write_param(self, node, ns, call, param_type, value): if len(call.arguments) < 1: return name = self._extract_topic(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME wrt = SetParamCall(name, ns, param_type, value=value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive = True)) node.write_param.append(wrt) self.log.debug("Found Write on %s/%s (%s) (%s)", ns, name, param_type, value) def _condition_location(self, condition_obj, sf): if sf is not None: if sf.path != condition_obj.file: self.log.debug(("condition Location: files do not match: " "'%s', '%s'"), sf.path, condition_obj.file) if condition_obj.file.startswith(self.package.path): for sf2 in self.package.source_files: if sf2.path == condition_obj.file: sf = sf2 break self.log.debug("Location: found correct file") return Location(self.package, file=sf, line=condition_obj.line, col=condition_obj.column, fun=condition_obj.function.name) def _call_location(self, call): try: source_file = next( sf for sf in self.package.source_files if sf.path == call.file) except StopIteration: source_file = None function = call.function if function: function = function.name return Location(self.package, file=source_file, line=call.line, col=call.column, fun=function) def _resolve_it_node_handle(self, value): value = resolve_expression(value) if (isinstance(value, CppFunctionCall) and value.name == "ImageTransport"): return self._resolve_node_handle(value.arguments[0]) return "?" def _resolve_node_handle(self, call): ns = "?" node_handle = getattr(call, 'method_of', None) or call if getattr(node_handle, 'name', None) == 'operator->': node_handle = node_handle.arguments[0] node_handle_def = None if isinstance(node_handle, CppReference): node_handle_def = resolve_reference(node_handle) elif isinstance(node_handle, CppDefaultArgument): return '' # A function needs to be called to create a NodeHandle (constructors # are functions) if isinstance(node_handle_def, CppFunctionCall): # node_handle_def is a call to the constructor if node_handle_def.name == 'NodeHandle': args = node_handle_def.arguments # Copy constructor if len(args) == 1: parent = args[0] if isinstance(parent, CppFunctionCall): if parent.name == 'getNodeHandle': return '' elif parent.name == 'getPrivateNodeHandle': return '~' return self._resolve_node_handle(parent) # All other constructor have at least two arguments. The third # is never meaningful # If a parent NodeHande is passed, it is the first argument # If a namespace argument is passed, it is either first or # second parameter. Only the first has an empty default value. prefix = '' if isinstance(args[0], basestring): ns = args[0] elif isinstance(args[0], CppDefaultArgument): ns = '' elif isinstance(args[1], basestring): prefix = self._resolve_node_handle(args[0]) ns = args[1] else: ns = "?" if prefix: ns = prefix + "/" + ns elif node_handle_def.name == 'getNodeHandle': ns = '' elif node_handle_def.name == 'getPrivateNodeHandle': ns = '~' elif isinstance(node_handle_def, CppDefaultArgument): ns = '' return ns def _extract_topic(self, call, topic_pos=0): name = resolve_expression(call.arguments[topic_pos]) if not isinstance(name, basestring): name = "?" return name or "?" def _extract_message_type(self, call): if call.template: template = call.template[0] std_alloc = re.search("_<std::allocator<void>", template) if std_alloc is not None: template = template[:std_alloc.start()] #assert re.match(r"\w+::\w+$", template) if not re.match(r"\w+::\w+$", template): self.log.debug("Weird message type: " + repr(template)) return template.replace("::", "/") if (call.name not in ("subscribe", "advertiseService") and 'NodeHandle' not in call.full_name): return "?" callback = (call.arguments[2] if call.name == "subscribe" else call.arguments[1]) while isinstance(callback, CppOperator): callback = callback.arguments[0] type_string = callback.result try: type_string = type_string.split(None, 1)[1] except IndexError: type_string = type_string.strip() if type_string.startswith("(*)"): type_string = type_string[3:] if type_string[0] == "(" and type_string[-1] == ")": type_string = type_string[1:-1] if call.name == "advertiseService": type_string = type_string.split(", ")[0] is_const = type_string.startswith("const ") if is_const: type_string = type_string[6:] is_ref = type_string.endswith(" &") if is_ref: type_string = type_string[:-2] is_ptr = type_string.endswith("::ConstPtr") if is_ptr: type_string = type_string[:-10] else: is_ptr = type_string.endswith("ConstPtr") if is_ptr: type_string = type_string[:-8] if type_string.endswith("::Request"): type_string = type_string[:-9] if type_string.startswith("boost::function"): type_string = type_string[52:-25] type_string = type_string.replace("::", "/") if re.match(r"\w+/\w+$", type_string): return type_string return "?" def _extract_action(self, call): name = "?" if "SimpleActionServer" in call.canonical_type and len(call.arguments) > 2: arg = call.arguments[1] if not isinstance(arg, basestring): arg = resolve_expression(arg) if isinstance(arg, basestring): name = arg.split()[-1].replace("'", "") elif "SimpleActionClient" in call.canonical_type and len(call.arguments) > 1: if isinstance(call.arguments[0], basestring): name = call.arguments[0] return name def _extract_action_type(self, call): type_string = call.template[0] return type_string.replace("::", "/") def _extract_action(self, call): name = "?" if "SimpleActionServer" in call.canonical_type and len(call.arguments) > 2: arg = call.arguments[1] if not isinstance(arg, basestring): arg = resolve_expression(arg) if isinstance(arg, basestring): name = arg.split()[-1].replace("'", "") elif "SimpleActionClient" in call.canonical_type and len(call.arguments) > 1: if isinstance(call.arguments[0], basestring): name = call.arguments[0] return name def _extract_action_type(self, call): type_string = call.template[0] return type_string.replace("::", "/") def _extract_queue_size(self, call, queue_pos=1): queue_size = resolve_expression(call.arguments[queue_pos]) if isinstance(queue_size, (int, float)): return queue_size return None def _extract_latch(self, call, latch_pos): expr = call.arguments[latch_pos] self.log.debug("extract latched publisher from {!r}".format(expr)) if isinstance(expr, CppDefaultArgument): self.log.debug("latch is default: false") return False latch = resolve_expression(expr) self.log.debug("resolve latch expr returns {!r}".format(latch)) if not isinstance(latch, bool): return None return latch def _extract_param_type(self, value): self.log.debug("extract param type from {}".format(repr(value))) if value is True or value is False: return "bool" if isinstance(value, int): return "int" if isinstance(value, float): return "double" if isinstance(value, basestring): return "str" cpp_type = getattr(value, "result", None) if cpp_type: self.log.debug("param type from C++ type {}".format(repr(cpp_type))) if cpp_type == "std::string" or cpp_type == "char *": return "str" if cpp_type == "int": return "int" if cpp_type == "double": return "double" if cpp_type == "bool": return "bool" return "yaml" if cpp_type else None def _extract_param_value(self, call, arg_pos=1): self.log.debug("extract_param_value({!r}, pos={})".format( call.arguments, arg_pos)) if len(call.arguments) <= arg_pos: self.log.debug("Failed to extract param value: not enough arguments") return None value = resolve_expression(call.arguments[arg_pos]) if isinstance(value, CppEntity): self.log.debug("Failed to extract param value: " + repr(value)) return None return value ############################################################################### # Python Primitive Extractor ############################################################################### class RospyExtractor(LoggingObject): queue_size_pos = { 'publisher': 6, 'subscriber': 4, } rospy_names = { 'publication': ('Publisher',), 'subscription': ('Subscriber',), 'service-def': ('Service',), 'service-call': ('ServiceProxy',), } @classmethod def all_rospy_names(cls, type): names = cls.rospy_names[type] return tuple('rospy.' + name for name in names) + names @staticmethod def get_arg(call, pos, name): try: return next( keyword.value for keyword in call.named_args if keyword.name == name) except StopIteration: try: return call.arguments[pos] except IndexError: return None @staticmethod def invalid_call(call, n=1): return (len(call.arguments) + len(call.named_args) + bool(call.star_args) + bool(call.kw_args)) <= n @staticmethod def split_ns_name(full_name): if '/' in full_name: ns, _, name = full_name.rpartition('/') else: ns, name = '', full_name return ns, name def _call_location(self, call): try: source_file = next( sf for sf in self.package.source_files if sf.path == call.file) except StopIteration: souce_file = None function = call.function if function: function = function.name return Location(self.package, file=source_file, line=call.line, fun=function) @classmethod def _extract_queue_size(cls, call): pos = cls.queue_size_pos[call.name.lower()] queue_size_arg = cls.get_arg(call, pos, 'queue_size') try: queue_size = resolve_expression(queue_size_arg) assert(isinstance(queue_size, (int, float))) return queue_size except AssertionError: return None @classmethod def _extract_message_type(cls, call, arg_name, msgs_imports, pkgs_imports, arg_pos=1): msg_type = cls.get_arg(call, 1, arg_name) # Very common case of calling type() on a message class if isinstance(msg_type, CodeFunctionCall) and msg_type.name == 'type': msg_type = msg_type.arguments[0].name if isinstance(msg_type, CodeReference): msg_type = resolve_reference(msg_type) or msg_type if isinstance(msg_type, CodeReference): if msg_type.field_of is None: for pkg_name, msg_name in msgs_imports: if msg_name == msg_type.name: return pkg_name + "/" + msg_name else: maybe_pkg = msg_type.field_of if isinstance(maybe_pkg, CodeReference): pkg_name = maybe_pkg.name if pkg_name in pkgs_imports: return pkg_name + "/" + msg_type.name return "?" @classmethod def _extract_topic(cls, call): name = resolve_expression(cls.get_arg(call, 0, 'name')) if not isinstance(name, basestring): name = '?' return cls.split_ns_name(name) def _on_client(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'service_class', self.msgs_list, self.pkgs_list) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] cli = ServiceClientCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.client.append(cli) self.log.debug("Found Client on %s/%s (%s)", ns, name, msg_type) def _on_publication(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'data_class', self.msgs_list, self.pkgs_list) queue_size = self._extract_queue_size(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] pub = AdvertiseCall(name, ns, msg_type, queue_size, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.advertise.append(pub) self.log.debug("Found AdvertiseCall on %s/%s (%s)", ns, name, msg_type) def _on_service(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'service_class', self.msgs_list, self.pkgs_list) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] srv = AdvertiseServiceCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.service.append(srv) self.log.debug("Found Service on %s/%s (%s)", ns, name, msg_type) def _on_subscription(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'data_class', self.msgs_list, self.pkgs_list) queue_size = self._extract_queue_size(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] sub = SubscribeCall(name, ns, msg_type, queue_size, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.subscribe.append(sub) self.log.debug("Found SubscribeCall on %s/%s (%s)", ns, name, msg_type) def _query_comm_primitives(self, node, gs): ################################## # Topics ################################## publications = (CodeQuery(gs).all_calls .where_name(('Publisher', 'rospy.Publisher')) .get()) subscriptions = (CodeQuery(gs).all_calls .where_name(('Subscriber', 'rospy.Subscriber')) .get()) for call in publications: self._on_publication(node, call) for call in subscriptions: self._on_subscription(node, call) ################################## # Services ################################## service_defs = (CodeQuery(gs).all_calls .where_name(self.all_rospy_names('service-def')) .get()) service_calls = (CodeQuery(gs).all_calls .where_name(self.all_rospy_names('service-call')) .get()) for call in service_defs: self._on_service(node, call) for call in service_calls: self._on_client(node, call) def _on_param_getter(self, node, call): if self.invalid_call(call, n=0): return name = resolve_expression(self.get_arg(call, 0, 'param_name')) if not isinstance(name, basestring): name = '?' ns, name = self.split_ns_name(name) param_type = None default_value = self.get_arg(call, 1, 'default') if default_value is not None: default_value = resolve_expression(default_value) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] getter = GetParamCall(name, ns, param_type, default_value=default_value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.read_param.append(getter) self.log.debug("Found GetParamCall on %s/%s", ns, name) def _on_param_setter(self, node, call): if self.invalid_call(call): return name = resolve_expression(self.get_arg(call, 0, 'param_name')) if not isinstance(name, basestring): name = '?' ns, name = self.split_ns_name(name) param_type = None value = resolve_expression(self.get_arg(call, 1, 'param_value')) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] setter = SetParamCall(name, ns, param_type, value=value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.write_param.append(setter) self.log.debug("Found SetParamCall on %s/%s", ns, name) def _query_param_primitives(self, node, gs): getters = (CodeQuery(gs).all_calls .where_name(('get_param', 'rospy.get_param')) .get()) setters = (CodeQuery(gs).all_calls .where_name(('set_param', 'rospy.set_param')) .get()) for call in getters: self._on_param_getter(node, call) for call in setters: self._on_param_setter(node, call) # FIXME: missing: # rospy.has_param(param_name) # rospy.delete_param(param_name) def _setup_path(self): setup_file = os.path.join(self.package.path, 'setup.py') if not os.path.isfile(setup_file): return [] parser = PyAstParser(workspace=self.package.path) setup = parser.parse(setup_file) setup_call = (CodeQuery(setup).all_calls .where_name('generate_distutils_setup') .get() or CodeQuery(setup).all_calls .where_name('setup') .get())[0] package_dir = self.get_arg(setup_call, 0, 'package_dir') if hasattr(package_dir, 'value'): package_dir = { keyword.name: keyword.value for keyword in self.get_arg(setup_call, 0, 'package_dir').value } else: src_path = os.path.join(self.package.path, 'src') package_dir = {'': 'src'} if os.path.exists(src_path) else {} root = package_dir.get('', '') return [os.path.join(self.package.path, root)] def __init__(self, package, workspace): self.package = package self.workspace = workspace self.pythonpath = self._setup_path() def extract(self, node): self.log.debug("Parsing Python files for node %s", node.id) self.log.debug("PyAstParser(pythonpath={!r}, workspace={!r})".format( self.pythonpath, self.workspace)) parser = PyAstParser(pythonpath=self.pythonpath, workspace=self.workspace) for sf in node.source_files: self.log.debug("Parsing Python file %s", sf.path) if parser.parse(sf.path) is None: self.log.warning("no compile commands for " + sf.path) node.source_tree = parser.global_scope # In theory the imported names list should not be needed here, this is a fix to be able to locate the complete description of ros msgs types (i.e. PkgName/MsgName self.msgs_list = [] self.pkgs_list = [] for imp_name in parser.imported_names_list: s = str(imp_name) if "msg" in s or "srv" in s: ss = s.split(".") if len(ss) < 2: continue if ss[-1] == "msg" or ss[-1] == "srv": self.pkgs_list.append(ss[0]) elif ss[1] == "msg" or ss[1] == "srv": self.msgs_list.append((ss[0], ss[2])) else: self.log.debug(("Python import with 'msg' or 'srv', " "but unable to process it: ") + s) # ----- queries after parsing, since global scope is reused ----------- self._query_comm_primitives(node, parser.global_scope) self._query_param_primitives(node, parser.global_scope) ############################################################################### # Node Hints ############################################################################### class NodeHints2(LoggingObject): # pkg/node: # fix: (fix variables) # advertise@1: name # getParam@1: true # advertise: (always adds) # - full JSON spec # - full JSON spec def __init__(self, hints, pkg_finder=None): if not isinstance(hints, dict): raise ValueError("expected dict of hints, got " + repr(hints)) for key, value in hints.items(): if not isinstance(key, basestring) or key.count("/") != 1: raise ValueError("expected 'pkg/node' key, found " + repr(key)) if not isinstance(value, dict): raise ValueError("expected dict value, found " + repr(value)) self.hints = hints self.pkg_finder = pkg_finder def apply_to(self, nodes, create=False): if not self.hints: return [] nodes = self._list_to_dict(nodes) if create and not self.pkg_finder: raise ValueError("received create=True but no pkg_finder") new_nodes = [] for node_type, node_hints in self.hints.items(): node = nodes.get(node_type) if node is not None: fix_hints = node_hints.get("fix", _EMPTY_DICT) if not isinstance(fix_hints, dict): raise ValueError("expected dict in {}:fix; got {!r}".format( node_type, fix_hints)) self.log.info("Merging extracted Node with hints: " + node_type) self.log.debug("node specs %s %s", node, node_hints) node.resolve_variables(fix_hints) elif create: self.log.info("Creating new Node from hints: " + node_type) self.log.debug("node specs %s %s", node_type, node_hints) node = self._create(node_type, node_hints) if node is not None: new_nodes.append(node) if node is not None: self._add_primitives(node, node_hints) hpl = node_hints.get("hpl", _EMPTY_DICT) node.hpl_properties = list(hpl.get("properties", _EMPTY_LIST)) node.hpl_assumptions = list(hpl.get("assumptions", _EMPTY_LIST)) return new_nodes def _create(self, node_type, hints): pkg_name, exe = node_type.split("/") pkg = self.pkg_finder.get("package:" + pkg_name) if pkg is None: self.log.error("Unable to find package: " + repr(pkg_name)) return None rosname = hints.get("rosname") nodelet_cls = hints.get("nodelet") node = Node(exe, pkg, rosname=rosname, nodelet=nodelet_cls) return node def _add_primitives(self, node, hints): for key, attr, cls in self._PRIMITIVES: calls = getattr(node, attr) for datum in hints.get(key, _EMPTY_LIST): call = cls.from_JSON_specs(datum) call.location = self._location_from_JSON(datum.get("location")) calls.append(call) _PRIMITIVES = ( ("advertise", "advertise", AdvertiseCall), ("subscribe", "subscribe", SubscribeCall), ("advertiseService", "service", AdvertiseServiceCall), ("serviceClient", "client", ServiceClientCall), ("getParam", "read_param", GetParamCall), ("setParam", "write_param", SetParamCall) ) def _list_to_dict(self, nodes): if isinstance(nodes, dict): return nodes return {node.node_name: node for node in nodes} # FIXME code duplication def _location_from_JSON(self, datum): if datum is None: return None pkg = self.pkg_finder.get("package:" + datum["package"]) if pkg is None: self.log.error("Unable to find package: " + repr(datum["package"])) return None source_file = None filename = datum["file"] if filename: try: source_file = next(sf for sf in pkg.source_files if sf.full_name == filename) except StopIteration: self.log.error("Unable to find file: '{}/{}'".format( datum["package"], filename)) return Location(pkg, file=source_file, line=datum.get("line", 1), col=datum.get("column", 1), fun=datum.get("function"), cls=datum.get("class"))

43.059314

170

0.549353

def _location_from_JSON(self, datum): if datum is None: return None try: pkg = self._get_package(datum["package"]) sf = None filename = datum["file"] if filename: sf = self._get_files(pkg, [filename])[0] except ValueError: return None return Location(pkg, file=sf, line=datum["line"], col=datum["column"], fun=datum["function"], cls=datum["class"]) package %s at %s", package, package.path) PackageParser._parse_metadata(root, package) PackageParser._parse_export(root, package) PackageParser._parse_dependencies(root, package) return package @staticmethod def _parse_metadata(xml, package): package.description = (xml.find("description").text or "").strip() for el in xml.findall("maintainer"): name = (el.text or "?").strip() email = el.get("email") or "email@example.com" package.maintainers.add(Person(name, email)) for el in xml.findall("author"): name = (el.text or "?").strip() email = el.get("email") or "email@example.com" package.authors.add(Person(name, email)) for el in xml.findall("license"): package.licenses.add((el.text or "?").strip()) for el in xml.findall("url"): value = el.get("type") if value is None or value == "website": if el.text: package.website = el.text.strip() elif value == "repository": if el.text: package.vcs_url = el.text.strip() elif value == "bugtracker": if el.text: package.bug_url = el.text.strip() el = xml.find("version") if el is not None: package.version = (el.text or "?").strip() @staticmethod def _parse_export(xml, package): el = xml.find("export") if not el is None: package.is_metapackage = not el.find("metapackage") is None if not el.find("nodelet") is None: nodelets = el.find("nodelet").get("plugin") nodelets = nodelets.replace("${prefix}", package.path) with open(nodelets, "r") as handle: xmltext = "<export>{}</export>".format(handle.read()) root = ET.fromstring(xmltext) PackageParser.log.info("Found nodelets at %s", nodelets) libs = [] for child in root: if child.tag == "library": libs.append(child) else: libs.extend(child.findall("library")) for el in libs: libname = el.get("path").rsplit(os.sep)[-1] for cl in el.findall("class"): nodelet = cl.get("type").split("::")[-1] node = Node(libname, package, nodelet = nodelet) package.nodes.append(node) @staticmethod def _parse_dependencies(xml, package): sources = ["build_depend"] if xml.get("format") == "2": sources.extend(("depend", "build_export_depend", "exec_depend")) else: sources.append("run_depend") for src in sources: for el in xml.findall(src): name = el.text.strip() if name: package.dependencies.packages.add(name) ############################################################################### # Hard-coded Node Parser ############################################################################### class HardcodedNodeParser(LoggingObject): model_dir = None distro = None _cache = {} @classmethod def get(cls, pkg, node_type): cls.log.debug("Fetching hard-coded node: (%s, %s, %s)", pkg, node_type, cls.distro) node_id = "node:" + pkg + "/" + node_type if node_id in cls._cache: cls.log.debug("Node already in cache.") return cls._cache[node_id] filename = os.path.join(cls.model_dir, pkg + ".yaml") try: with open(filename) as handle: data = yaml.safe_load(handle) except IOError as e: cls.log.debug("YAML file not found: %s", filename) return None if not cls.distro in data: cls.log.debug("Package has no data for ROS %s.", cls.distro) return None if not node_type in data[cls.distro]: cls.log.debug("Node does not exist for ROS %s.", cls.distro) return None cls.log.debug("Building node from YAML data.") pkg = Package(pkg) pkg.path = "/tmp/" + pkg.name node = cls._build_node(node_type, cls.distro, pkg, data) cls._cache[node_id] = node return node @classmethod def _build_node(cls, node_type, distro, pkg, data): node_data = data[distro][node_type] base = node_data.get("base") if base: node = cls._build_node(node_type, base, pkg, data) else: node = Node(node_type, pkg, rosname = node_data.get("rosname"), nodelet = node_type if node_data["nodelet"] else None) for datum in node_data.get("advertise", ()): loc = cls._loc(pkg, datum) pub = AdvertiseCall(datum["name"], datum["namespace"], datum["type"], datum["queue"], latched=datum.get("latched", False), control_depth=datum["depth"], repeats=datum["repeats"], conditions=[SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.advertise.append(pub) for datum in node_data.get("subscribe", ()): loc = cls._loc(pkg, datum) sub = SubscribeCall(datum["name"], datum["namespace"], datum["type"], datum["queue"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = [SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.subscribe.append(sub) for datum in node_data.get("service", ()): loc = cls._loc(pkg, datum) srv = AdvertiseServiceCall(datum["name"], datum["namespace"], datum["type"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = [SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.service.append(srv) for datum in node_data.get("client", ()): loc = cls._loc(pkg, datum) cli = ServiceClientCall(datum["name"], datum["namespace"], datum["type"], control_depth = datum["depth"], repeats = datum["repeats"], conditions = [SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.client.append(cli) for datum in node_data.get("readParam", ()): loc = cls._loc(pkg, datum) par = GetParamCall(datum["name"], datum["namespace"], datum["type"], default_value=datum.get("default"), control_depth=datum["depth"], repeats=datum["repeats"], conditions=[SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.read_param.append(par) for datum in node_data.get("writeParam", ()): loc = cls._loc(pkg, datum) par = SetParamCall(datum["name"], datum["namespace"], datum["type"], value=datum.get("value"), control_depth=datum["depth"], repeats=datum["repeats"], conditions=[SourceCondition(c["condition"], statement=c["statement"]) for c in datum["conditions"]], location=loc) node.write_param.append(par) cls.log.debug("Hard-coded Node: " + str(node.to_JSON_object())) return node @classmethod def _loc(cls, pkg, data): loc = data.get("location") if loc is None: return None p = loc.get("package") if p is None or p != pkg.name: return None f = loc["file"] for sf in pkg.source_files: if sf.full_name == f: f = sf break else: parts = loc["file"].rsplit("/", 1) if len(parts) == 1: directory = "" name = parts[0] else: assert len(parts) == 2 directory, name = parts f = SourceFile(name, directory, pkg) pkg.source_files.append(f) return Location(pkg, file=f, line=loc["line"], col=loc["column"], fun=loc.get("function"), cls=loc.get("class")) ############################################################################### # Node Extractor ############################################################################### class NodeExtractor(LoggingObject): def __init__(self, pkgs, env, ws=None, node_cache=None, parse_nodes=False): self.package = None self.packages = pkgs self.environment = env self.workspace = ws self.node_cache = node_cache self.parse_nodes = parse_nodes self.nodes = [] self.roscpp_extractor = None self.rospy_extractor = None def find_nodes(self, pkg): self.log.debug("NodeExtractor.find_nodes(%s)", pkg) self.package = pkg srcdir = self.package.path[len(self.workspace):] srcdir = os.path.join(self.workspace, srcdir.split(os.sep, 1)[0]) bindir = os.path.join(self.workspace, "build") cmake_path = os.path.join(self.package.path, "CMakeLists.txt") if os.path.isfile(cmake_path): parser = RosCMakeParser(srcdir, bindir, pkgs = self.packages, env = self.environment, vars = self._default_variables()) parser.parse(cmake_path) self._update_nodelets(parser.libraries) self._register_nodes(parser.executables) else: # It may be normal for pure Python projects not to have a CMakeLists.txt # Instead, search for python files with "def main():" pattern = re.compile('^def\s+main\s*$.*$\s*:') for file in pkg.source_files: if file.language != 'python': continue # continue with next file entry_point_found = False with open(file.path) as f: for line in f: match = pattern.match(line) if match is not None: entry_point_found = True break if entry_point_found == False: continue # continue with next file # else: this is a python file with a 'main' function, # so we consider it a node. node = Node(file.full_name, pkg) node.source_files.append(file) self.nodes.append(node) self.package.nodes.append(node) if self.parse_nodes: self._extract_primitives() def _default_variables(self): # TODO: clean up these hardcoded values v = {} v["catkin_INCLUDE_DIRS"] = os.path.join(self.workspace, "devel/include") v["Boost_INCLUDE_DIRS"] = "/usr/include/" v["Eigen_INCLUDE_DIRS"] = "/usr/include/eigen3" v["ImageMagick_INCLUDE_DIRS"] = "/usr/include/ImageMagick" v["PROJECT_SOURCE_DIR"] = self.package.path return v def _get_file(self, path): for sf in self.package.source_files: if sf.path == path: return sf return None def _update_nodelets(self, libraries): lib_files = {} for target in libraries.values(): files = [] for path in target.files: sf = self._get_file(path) if sf: files.append(sf) for link in target.links: for path in link.files: sf = self._get_file(path) if sf: files.append(sf) lib_files[target.prefixed_name] = files for nodelet in self.package.nodes: if not nodelet.is_nodelet: continue if nodelet.name in lib_files: nodelet.source_files = lib_files[nodelet.name] def _register_nodes(self, executables): for target in executables.values(): node = Node(target.output_name, self.package) for path in target.files: sf = self._get_file(path) if sf: node.source_files.append(sf) for link in target.links: for path in link.files: sf = self._get_file(path) if sf: node.source_files.append(sf) lang = node.language if lang == "cpp" or lang == "python": self.log.debug("register %s node: %s", lang, node.node_name) self.nodes.append(node) self.package.nodes.append(node) else: self.log.debug("CMake target is not a node: %s (%s) %s", node.node_name, lang, node.source_files) def _extract_primitives(self, force_when_cached=False): self.roscpp_extractor = RoscppExtractor(self.package, self.workspace) self.rospy_extractor = RospyExtractor(self.package, self.workspace) for i in range(len(self.package.nodes)): node = self.package.nodes[i] self.log.debug("Extracting primitives for node %s", node.id) if node.source_tree is not None: self.log.debug("Node already has a source tree. Skipped.") continue if (node.node_name in self.node_cache) and not force_when_cached: self.log.debug("Using Node %s from cache.", node.node_name) node = self.node_cache[node.node_name] assert node.package is self.package self.package.nodes[i] = node continue node.source_tree = CodeGlobalScope() node.advertise = [] node.subscribe = [] node.service = [] node.client = [] node.read_param = [] node.write_param = [] if not node.source_files: self.log.warning("no source files for node " + node.id) if node.language == "cpp" and CppAstParser is not None: self.roscpp_extractor.extract(node) elif node.language == "python": self.rospy_extractor.extract(node) else: self.log.debug("Node written in %s.", node.language) self.log.debug("Skipping parsing and primitive extraction.") ############################################################################### # C++ Primitive Extractor ############################################################################### class RoscppExtractor(LoggingObject): def __init__(self, package, workspace): self.package = package self.workspace = workspace def extract(self, node): self.log.debug("Parsing C++ files for node %s", node.id) parser = CppAstParser(workspace=self.workspace, logger=__name__) for sf in node.source_files: self.log.debug("Parsing C++ file %s", sf.path) if parser.parse(sf.path) is None: self.log.warning("no compile commands for " + sf.path) node.source_tree = parser.global_scope # ----- queries after parsing, since global scope is reused ----------- self._query_comm_primitives(node, parser.global_scope) self._query_nh_param_primitives(node, parser.global_scope) self._query_param_primitives(node, parser.global_scope) def _query_comm_primitives(self, node, gs): for call in CodeQuery(gs).all_calls.where_name("advertise").get(): if call.canonical_type != "ros::Publisher": continue self._on_publication(node, self._resolve_node_handle(call.method_of), call) for call in CodeQuery(gs).all_calls.where_name("subscribe").get(): if call.canonical_type != "ros::Subscriber": continue self._on_subscription(node, self._resolve_node_handle(call.method_of), call) for call in CodeQuery(gs).all_calls.where_name("advertiseService").get(): if call.canonical_type != "ros::ServiceServer": continue self._on_service(node, self._resolve_node_handle(call.method_of), call) for call in CodeQuery(gs).all_calls.where_name("serviceClient").get(): if call.canonical_type != "ros::ServiceClient": continue self._on_client(node, self._resolve_node_handle(call.method_of), call) self.log.debug("Looking for image_transport::SubscriberFilter calls.") for call in CodeQuery(gs).all_calls.where_name("SubscriberFilter").get(): self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) if isinstance(call.reference, str): if not call.reference.startswith("c:@N@image_transport@S@SubscriberFilter"): continue if not "image_transport::SubscriberFilter" in call.canonical_type: continue n = call.arguments[0] if call.arguments else None self._on_subscription(node, self._resolve_it_node_handle(n), call, topic_pos = 1, queue_pos = 2, msg_type = "sensor_msgs/Image") self.log.debug("Looking for message_filters::Subscriber calls.") for call in CodeQuery(gs).all_calls.where_name("Subscriber").get(): self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) if isinstance(call.reference, str): if not call.reference.startswith("c:@N@message_filters@S@Subscriber"): continue if not "message_filters::Subscriber" in call.canonical_type: continue n = call.arguments[0] if call.arguments else None self._on_subscription(node, self._resolve_node_handle(n), call, topic_pos = 1, queue_pos = 2) self.log.debug("Looking for image_transport::Subscriber calls.") for call in CodeQuery(gs).all_calls.where_name("subscribe").get(): if call.canonical_type != "image_transport::Subscriber": continue self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) n = call.method_of if call.method_of else None self._on_subscription(node, self._resolve_it_node_handle(n), call, msg_type = "sensor_msgs/Image") self.log.debug("Looking for image_transport::Publisher.") for call in CodeQuery(gs).all_calls.where_name("advertise").get(): if call.canonical_type != "image_transport::Publisher": continue self.log.debug("Found: %s", call.pretty_str()) self.log.debug("%s", type(call)) self.log.debug("%s", call.__dict__) n = call.method_of if call.method_of else None self._on_publication(node, self._resolve_it_node_handle(n), call, msg_type = "sensor_msgs/Image") def _query_nh_param_primitives(self, node, gs): nh_prefix = "c:@N@ros@S@NodeHandle@" gets = ("getParam", "getParamCached", "param") reads = gets + ("hasParam", "searchParam") for call in CodeQuery(gs).all_calls.where_name(reads).get(): if (call.full_name.startswith("ros::NodeHandle") or (isinstance(call.reference, str) and call.reference.startswith(nh_prefix))): param_type = default_value = None if call.name in gets: param_type = self._extract_param_type(call.arguments[1]) if call.name == "param": if len(call.arguments) > 2: default_value = self._extract_param_value( call, arg_pos=2) elif len(call.arguments) == 2: default_value = self._extract_param_value( call, arg_pos=1) self._on_read_param(node, self._resolve_node_handle(call), call, param_type, default_value) sets = ("setParam",) writes = sets + ("deleteParam",) for call in CodeQuery(gs).all_calls.where_name(writes).get(): if (call.full_name.startswith("ros::NodeHandle") or (isinstance(call.reference, str) and call.reference.startswith(nh_prefix))): param_type = value = None if len(call.arguments) >= 2 and call.name in sets: param_type = self._extract_param_type(call.arguments[1]) value = self._extract_param_value(call, arg_pos=1) self._on_write_param(node, self._resolve_node_handle(call), call, param_type, value) def _query_param_primitives(self, node, gs): ros_prefix = "c:@N@ros@N@param@" gets = ("get", "getCached", "param") reads = gets + ("has",) for call in CodeQuery(gs).all_calls.where_name(reads).get(): if (call.full_name.startswith("ros::param") or (isinstance(call.reference, str) and call.reference.startswith(ros_prefix))): param_type = default_value = None if call.name in gets: param_type = self._extract_param_type(call.arguments[1]) if call.name == "param": if len(call.arguments) > 2: default_value = self._extract_param_value( call, arg_pos=2) elif len(call.arguments) == 2: default_value = self._extract_param_value( call, arg_pos=1) self._on_read_param(node, "", call, param_type, default_value) for call in (CodeQuery(gs).all_calls.where_name("search") .where_result("bool").get()): if (call.full_name.startswith("ros::param") or (isinstance(call.reference, str) and call.reference.startswith(ros_prefix))): if len(call.arguments) > 2: ns = resolve_expression(call.arguments[0]) if not isinstance(ns, basestring): ns = "?" else: ns = "~" self._on_read_param(node, ns, call, None, None) sets = ("set",) writes = sets + ("del",) for call in CodeQuery(gs).all_calls.where_name(writes).get(): if (call.full_name.startswith("ros::param") or (isinstance(call.reference, str) and call.reference.startswith(ros_prefix))): param_type = value = None if len(call.arguments) >= 2 and call.name in sets: param_type = self._extract_param_type(call.arguments[1]) value = self._extract_param_value(call, arg_pos=1) self._on_write_param(node, "", call, param_type, value) def _on_publication(self, node, ns, call, topic_pos=0, queue_pos=1, msg_type=None, latch_pos=-1): if len(call.arguments) <= 1: return name = self._extract_topic(call, topic_pos=topic_pos) msg_type = msg_type or self._extract_message_type(call) queue_size = self._extract_queue_size(call, queue_pos=queue_pos) latched = False if len(call.arguments) >= 3 and len(call.arguments) > latch_pos: latched = self._extract_latch(call, latch_pos) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME pub = AdvertiseCall(name, ns, msg_type, queue_size, latched=latched, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.advertise.append(pub) self.log.debug("Found AdvertiseCall on %s/%s (%s)", ns, name, msg_type) def _on_subscription(self, node, ns, call, topic_pos=0, queue_pos=1, msg_type=None): if len(call.arguments) <= 1: return name = self._extract_topic(call, topic_pos=topic_pos) msg_type = msg_type or self._extract_message_type(call) queue_size = self._extract_queue_size(call, queue_pos=queue_pos) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME sub = SubscribeCall(name, ns, msg_type, queue_size, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.subscribe.append(sub) self.log.debug("Found SubscribeCall on %s/%s (%s)", ns, name, msg_type) def _on_service(self, node, ns, call): if len(call.arguments) <= 1: return name = self._extract_topic(call) msg_type = self._extract_message_type(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME srv = AdvertiseServiceCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.service.append(srv) self.log.debug("Found Service on %s/%s (%s)", ns, name, msg_type) def _on_client(self, node, ns, call): if len(call.arguments) <= 1: return name = self._extract_topic(call) msg_type = self._extract_message_type(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME cli = ServiceClientCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.client.append(cli) self.log.debug("Found Client on %s/%s (%s)", ns, name, msg_type) def _on_read_param(self, node, ns, call, param_type, default_value): if len(call.arguments) < 1: return name = self._extract_topic(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME read = GetParamCall(name, ns, param_type, default_value=default_value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive = True)) node.read_param.append(read) self.log.debug("Found Read on %s/%s (%s) (%s)", ns, name, param_type, default_value) def _on_write_param(self, node, ns, call, param_type, value): if len(call.arguments) < 1: return name = self._extract_topic(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [] for path in get_condition_paths(call): for c in path: conditions.append(SourceCondition(pretty_str(c.value), location=self._condition_location(c, location.file), statement=c.statement)) break # FIXME wrt = SetParamCall(name, ns, param_type, value=value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive = True)) node.write_param.append(wrt) self.log.debug("Found Write on %s/%s (%s) (%s)", ns, name, param_type, value) def _condition_location(self, condition_obj, sf): if sf is not None: if sf.path != condition_obj.file: self.log.debug(("condition Location: files do not match: " "'%s', '%s'"), sf.path, condition_obj.file) if condition_obj.file.startswith(self.package.path): for sf2 in self.package.source_files: if sf2.path == condition_obj.file: sf = sf2 break self.log.debug("Location: found correct file") return Location(self.package, file=sf, line=condition_obj.line, col=condition_obj.column, fun=condition_obj.function.name) def _call_location(self, call): try: source_file = next( sf for sf in self.package.source_files if sf.path == call.file) except StopIteration: source_file = None function = call.function if function: function = function.name return Location(self.package, file=source_file, line=call.line, col=call.column, fun=function) def _resolve_it_node_handle(self, value): value = resolve_expression(value) if (isinstance(value, CppFunctionCall) and value.name == "ImageTransport"): return self._resolve_node_handle(value.arguments[0]) return "?" def _resolve_node_handle(self, call): ns = "?" node_handle = getattr(call, 'method_of', None) or call if getattr(node_handle, 'name', None) == 'operator->': node_handle = node_handle.arguments[0] node_handle_def = None if isinstance(node_handle, CppReference): node_handle_def = resolve_reference(node_handle) elif isinstance(node_handle, CppDefaultArgument): return '' # A function needs to be called to create a NodeHandle (constructors # are functions) if isinstance(node_handle_def, CppFunctionCall): # node_handle_def is a call to the constructor if node_handle_def.name == 'NodeHandle': args = node_handle_def.arguments # Copy constructor if len(args) == 1: parent = args[0] if isinstance(parent, CppFunctionCall): if parent.name == 'getNodeHandle': return '' elif parent.name == 'getPrivateNodeHandle': return '~' return self._resolve_node_handle(parent) # All other constructor have at least two arguments. The third # is never meaningful # If a parent NodeHande is passed, it is the first argument # If a namespace argument is passed, it is either first or # second parameter. Only the first has an empty default value. prefix = '' if isinstance(args[0], basestring): ns = args[0] elif isinstance(args[0], CppDefaultArgument): ns = '' elif isinstance(args[1], basestring): prefix = self._resolve_node_handle(args[0]) ns = args[1] else: ns = "?" if prefix: ns = prefix + "/" + ns elif node_handle_def.name == 'getNodeHandle': ns = '' elif node_handle_def.name == 'getPrivateNodeHandle': ns = '~' elif isinstance(node_handle_def, CppDefaultArgument): ns = '' return ns def _extract_topic(self, call, topic_pos=0): name = resolve_expression(call.arguments[topic_pos]) if not isinstance(name, basestring): name = "?" return name or "?" def _extract_message_type(self, call): if call.template: template = call.template[0] std_alloc = re.search("_<std::allocator<void>", template) if std_alloc is not None: template = template[:std_alloc.start()] #assert re.match(r"\w+::\w+$", template) if not re.match(r"\w+::\w+$", template): self.log.debug("Weird message type: " + repr(template)) return template.replace("::", "/") if (call.name not in ("subscribe", "advertiseService") and 'NodeHandle' not in call.full_name): return "?" callback = (call.arguments[2] if call.name == "subscribe" else call.arguments[1]) while isinstance(callback, CppOperator): callback = callback.arguments[0] type_string = callback.result try: type_string = type_string.split(None, 1)[1] except IndexError: type_string = type_string.strip() if type_string.startswith("(*)"): type_string = type_string[3:] if type_string[0] == "(" and type_string[-1] == ")": type_string = type_string[1:-1] if call.name == "advertiseService": type_string = type_string.split(", ")[0] is_const = type_string.startswith("const ") if is_const: type_string = type_string[6:] is_ref = type_string.endswith(" &") if is_ref: type_string = type_string[:-2] is_ptr = type_string.endswith("::ConstPtr") if is_ptr: type_string = type_string[:-10] else: is_ptr = type_string.endswith("ConstPtr") if is_ptr: type_string = type_string[:-8] if type_string.endswith("::Request"): type_string = type_string[:-9] if type_string.startswith("boost::function"): type_string = type_string[52:-25] type_string = type_string.replace("::", "/") if re.match(r"\w+/\w+$", type_string): return type_string return "?" def _extract_action(self, call): name = "?" if "SimpleActionServer" in call.canonical_type and len(call.arguments) > 2: arg = call.arguments[1] if not isinstance(arg, basestring): arg = resolve_expression(arg) if isinstance(arg, basestring): name = arg.split()[-1].replace("'", "") elif "SimpleActionClient" in call.canonical_type and len(call.arguments) > 1: if isinstance(call.arguments[0], basestring): name = call.arguments[0] return name def _extract_action_type(self, call): type_string = call.template[0] return type_string.replace("::", "/") def _extract_action(self, call): name = "?" if "SimpleActionServer" in call.canonical_type and len(call.arguments) > 2: arg = call.arguments[1] if not isinstance(arg, basestring): arg = resolve_expression(arg) if isinstance(arg, basestring): name = arg.split()[-1].replace("'", "") elif "SimpleActionClient" in call.canonical_type and len(call.arguments) > 1: if isinstance(call.arguments[0], basestring): name = call.arguments[0] return name def _extract_action_type(self, call): type_string = call.template[0] return type_string.replace("::", "/") def _extract_queue_size(self, call, queue_pos=1): queue_size = resolve_expression(call.arguments[queue_pos]) if isinstance(queue_size, (int, float)): return queue_size return None def _extract_latch(self, call, latch_pos): expr = call.arguments[latch_pos] self.log.debug("extract latched publisher from {!r}".format(expr)) if isinstance(expr, CppDefaultArgument): self.log.debug("latch is default: false") return False latch = resolve_expression(expr) self.log.debug("resolve latch expr returns {!r}".format(latch)) if not isinstance(latch, bool): return None return latch def _extract_param_type(self, value): self.log.debug("extract param type from {}".format(repr(value))) if value is True or value is False: return "bool" if isinstance(value, int): return "int" if isinstance(value, float): return "double" if isinstance(value, basestring): return "str" cpp_type = getattr(value, "result", None) if cpp_type: self.log.debug("param type from C++ type {}".format(repr(cpp_type))) if cpp_type == "std::string" or cpp_type == "char *": return "str" if cpp_type == "int": return "int" if cpp_type == "double": return "double" if cpp_type == "bool": return "bool" return "yaml" if cpp_type else None def _extract_param_value(self, call, arg_pos=1): self.log.debug("extract_param_value({!r}, pos={})".format( call.arguments, arg_pos)) if len(call.arguments) <= arg_pos: self.log.debug("Failed to extract param value: not enough arguments") return None value = resolve_expression(call.arguments[arg_pos]) if isinstance(value, CppEntity): self.log.debug("Failed to extract param value: " + repr(value)) return None return value ############################################################################### # Python Primitive Extractor ############################################################################### class RospyExtractor(LoggingObject): queue_size_pos = { 'publisher': 6, 'subscriber': 4, } rospy_names = { 'publication': ('Publisher',), 'subscription': ('Subscriber',), 'service-def': ('Service',), 'service-call': ('ServiceProxy',), } @classmethod def all_rospy_names(cls, type): names = cls.rospy_names[type] return tuple('rospy.' + name for name in names) + names @staticmethod def get_arg(call, pos, name): try: return next( keyword.value for keyword in call.named_args if keyword.name == name) except StopIteration: try: return call.arguments[pos] except IndexError: return None @staticmethod def invalid_call(call, n=1): return (len(call.arguments) + len(call.named_args) + bool(call.star_args) + bool(call.kw_args)) <= n @staticmethod def split_ns_name(full_name): if '/' in full_name: ns, _, name = full_name.rpartition('/') else: ns, name = '', full_name return ns, name def _call_location(self, call): try: source_file = next( sf for sf in self.package.source_files if sf.path == call.file) except StopIteration: souce_file = None function = call.function if function: function = function.name return Location(self.package, file=source_file, line=call.line, fun=function) @classmethod def _extract_queue_size(cls, call): pos = cls.queue_size_pos[call.name.lower()] queue_size_arg = cls.get_arg(call, pos, 'queue_size') try: queue_size = resolve_expression(queue_size_arg) assert(isinstance(queue_size, (int, float))) return queue_size except AssertionError: return None @classmethod def _extract_message_type(cls, call, arg_name, msgs_imports, pkgs_imports, arg_pos=1): msg_type = cls.get_arg(call, 1, arg_name) # Very common case of calling type() on a message class if isinstance(msg_type, CodeFunctionCall) and msg_type.name == 'type': msg_type = msg_type.arguments[0].name if isinstance(msg_type, CodeReference): msg_type = resolve_reference(msg_type) or msg_type if isinstance(msg_type, CodeReference): if msg_type.field_of is None: for pkg_name, msg_name in msgs_imports: if msg_name == msg_type.name: return pkg_name + "/" + msg_name else: maybe_pkg = msg_type.field_of if isinstance(maybe_pkg, CodeReference): pkg_name = maybe_pkg.name if pkg_name in pkgs_imports: return pkg_name + "/" + msg_type.name return "?" @classmethod def _extract_topic(cls, call): name = resolve_expression(cls.get_arg(call, 0, 'name')) if not isinstance(name, basestring): name = '?' return cls.split_ns_name(name) def _on_client(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'service_class', self.msgs_list, self.pkgs_list) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] cli = ServiceClientCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.client.append(cli) self.log.debug("Found Client on %s/%s (%s)", ns, name, msg_type) def _on_publication(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'data_class', self.msgs_list, self.pkgs_list) queue_size = self._extract_queue_size(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] pub = AdvertiseCall(name, ns, msg_type, queue_size, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.advertise.append(pub) self.log.debug("Found AdvertiseCall on %s/%s (%s)", ns, name, msg_type) def _on_service(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'service_class', self.msgs_list, self.pkgs_list) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] srv = AdvertiseServiceCall(name, ns, msg_type, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.service.append(srv) self.log.debug("Found Service on %s/%s (%s)", ns, name, msg_type) def _on_subscription(self, node, call): if self.invalid_call(call): return ns, name = self._extract_topic(call) msg_type = self._extract_message_type(call, 'data_class', self.msgs_list, self.pkgs_list) queue_size = self._extract_queue_size(call) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] sub = SubscribeCall(name, ns, msg_type, queue_size, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.subscribe.append(sub) self.log.debug("Found SubscribeCall on %s/%s (%s)", ns, name, msg_type) def _query_comm_primitives(self, node, gs): ################################## # Topics ################################## publications = (CodeQuery(gs).all_calls .where_name(('Publisher', 'rospy.Publisher')) .get()) subscriptions = (CodeQuery(gs).all_calls .where_name(('Subscriber', 'rospy.Subscriber')) .get()) for call in publications: self._on_publication(node, call) for call in subscriptions: self._on_subscription(node, call) ################################## # Services ################################## service_defs = (CodeQuery(gs).all_calls .where_name(self.all_rospy_names('service-def')) .get()) service_calls = (CodeQuery(gs).all_calls .where_name(self.all_rospy_names('service-call')) .get()) for call in service_defs: self._on_service(node, call) for call in service_calls: self._on_client(node, call) def _on_param_getter(self, node, call): if self.invalid_call(call, n=0): return name = resolve_expression(self.get_arg(call, 0, 'param_name')) if not isinstance(name, basestring): name = '?' ns, name = self.split_ns_name(name) param_type = None default_value = self.get_arg(call, 1, 'default') if default_value is not None: default_value = resolve_expression(default_value) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] getter = GetParamCall(name, ns, param_type, default_value=default_value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.read_param.append(getter) self.log.debug("Found GetParamCall on %s/%s", ns, name) def _on_param_setter(self, node, call): if self.invalid_call(call): return name = resolve_expression(self.get_arg(call, 0, 'param_name')) if not isinstance(name, basestring): name = '?' ns, name = self.split_ns_name(name) param_type = None value = resolve_expression(self.get_arg(call, 1, 'param_value')) depth = get_control_depth(call, recursive=True) location = self._call_location(call) conditions = [SourceCondition(pretty_str(c), location=location) for c in get_conditions(call, recursive=True)] setter = SetParamCall(name, ns, param_type, value=value, location=location, control_depth=depth, conditions=conditions, repeats=is_under_loop(call, recursive=True)) node.write_param.append(setter) self.log.debug("Found SetParamCall on %s/%s", ns, name) def _query_param_primitives(self, node, gs): getters = (CodeQuery(gs).all_calls .where_name(('get_param', 'rospy.get_param')) .get()) setters = (CodeQuery(gs).all_calls .where_name(('set_param', 'rospy.set_param')) .get()) for call in getters: self._on_param_getter(node, call) for call in setters: self._on_param_setter(node, call) # FIXME: missing: # rospy.has_param(param_name) # rospy.delete_param(param_name) def _setup_path(self): setup_file = os.path.join(self.package.path, 'setup.py') if not os.path.isfile(setup_file): return [] parser = PyAstParser(workspace=self.package.path) setup = parser.parse(setup_file) setup_call = (CodeQuery(setup).all_calls .where_name('generate_distutils_setup') .get() or CodeQuery(setup).all_calls .where_name('setup') .get())[0] package_dir = self.get_arg(setup_call, 0, 'package_dir') if hasattr(package_dir, 'value'): package_dir = { keyword.name: keyword.value for keyword in self.get_arg(setup_call, 0, 'package_dir').value } else: src_path = os.path.join(self.package.path, 'src') package_dir = {'': 'src'} if os.path.exists(src_path) else {} root = package_dir.get('', '') return [os.path.join(self.package.path, root)] def __init__(self, package, workspace): self.package = package self.workspace = workspace self.pythonpath = self._setup_path() def extract(self, node): self.log.debug("Parsing Python files for node %s", node.id) self.log.debug("PyAstParser(pythonpath={!r}, workspace={!r})".format( self.pythonpath, self.workspace)) parser = PyAstParser(pythonpath=self.pythonpath, workspace=self.workspace) for sf in node.source_files: self.log.debug("Parsing Python file %s", sf.path) if parser.parse(sf.path) is None: self.log.warning("no compile commands for " + sf.path) node.source_tree = parser.global_scope # In theory the imported names list should not be needed here, this is a fix to be able to locate the complete description of ros msgs types (i.e. PkgName/MsgName self.msgs_list = [] self.pkgs_list = [] for imp_name in parser.imported_names_list: s = str(imp_name) if "msg" in s or "srv" in s: ss = s.split(".") if len(ss) < 2: continue if ss[-1] == "msg" or ss[-1] == "srv": self.pkgs_list.append(ss[0]) elif ss[1] == "msg" or ss[1] == "srv": self.msgs_list.append((ss[0], ss[2])) else: self.log.debug(("Python import with 'msg' or 'srv', " "but unable to process it: ") + s) # ----- queries after parsing, since global scope is reused ----------- self._query_comm_primitives(node, parser.global_scope) self._query_param_primitives(node, parser.global_scope) ############################################################################### # Node Hints ############################################################################### class NodeHints2(LoggingObject): # pkg/node: # fix: (fix variables) # advertise@1: name # getParam@1: true # advertise: (always adds) # - full JSON spec # - full JSON spec def __init__(self, hints, pkg_finder=None): if not isinstance(hints, dict): raise ValueError("expected dict of hints, got " + repr(hints)) for key, value in hints.items(): if not isinstance(key, basestring) or key.count("/") != 1: raise ValueError("expected 'pkg/node' key, found " + repr(key)) if not isinstance(value, dict): raise ValueError("expected dict value, found " + repr(value)) self.hints = hints self.pkg_finder = pkg_finder def apply_to(self, nodes, create=False): if not self.hints: return [] nodes = self._list_to_dict(nodes) if create and not self.pkg_finder: raise ValueError("received create=True but no pkg_finder") new_nodes = [] for node_type, node_hints in self.hints.items(): node = nodes.get(node_type) if node is not None: fix_hints = node_hints.get("fix", _EMPTY_DICT) if not isinstance(fix_hints, dict): raise ValueError("expected dict in {}:fix; got {!r}".format( node_type, fix_hints)) self.log.info("Merging extracted Node with hints: " + node_type) self.log.debug("node specs %s %s", node, node_hints) node.resolve_variables(fix_hints) elif create: self.log.info("Creating new Node from hints: " + node_type) self.log.debug("node specs %s %s", node_type, node_hints) node = self._create(node_type, node_hints) if node is not None: new_nodes.append(node) if node is not None: self._add_primitives(node, node_hints) hpl = node_hints.get("hpl", _EMPTY_DICT) node.hpl_properties = list(hpl.get("properties", _EMPTY_LIST)) node.hpl_assumptions = list(hpl.get("assumptions", _EMPTY_LIST)) return new_nodes def _create(self, node_type, hints): pkg_name, exe = node_type.split("/") pkg = self.pkg_finder.get("package:" + pkg_name) if pkg is None: self.log.error("Unable to find package: " + repr(pkg_name)) return None rosname = hints.get("rosname") nodelet_cls = hints.get("nodelet") node = Node(exe, pkg, rosname=rosname, nodelet=nodelet_cls) return node def _add_primitives(self, node, hints): for key, attr, cls in self._PRIMITIVES: calls = getattr(node, attr) for datum in hints.get(key, _EMPTY_LIST): call = cls.from_JSON_specs(datum) call.location = self._location_from_JSON(datum.get("location")) calls.append(call) _PRIMITIVES = ( ("advertise", "advertise", AdvertiseCall), ("subscribe", "subscribe", SubscribeCall), ("advertiseService", "service", AdvertiseServiceCall), ("serviceClient", "client", ServiceClientCall), ("getParam", "read_param", GetParamCall), ("setParam", "write_param", SetParamCall) ) def _list_to_dict(self, nodes): if isinstance(nodes, dict): return nodes return {node.node_name: node for node in nodes} # FIXME code duplication def _location_from_JSON(self, datum): if datum is None: return None pkg = self.pkg_finder.get("package:" + datum["package"]) if pkg is None: self.log.error("Unable to find package: " + repr(datum["package"])) return None source_file = None filename = datum["file"] if filename: try: source_file = next(sf for sf in pkg.source_files if sf.full_name == filename) except StopIteration: self.log.error("Unable to find file: '{}/{}'".format( datum["package"], filename)) return Location(pkg, file=source_file, line=datum.get("line", 1), col=datum.get("column", 1), fun=datum.get("function"), cls=datum.get("class"))

true

f71312233704eae50bc57397e9568504e17aef63

1,539

py

Python

examples/node2vec_wiki.py

1172939260/GE

df8bc2bb514b4f890764c26f3d36fad4c99de1cc

[ "MIT" ]

3

2020-04-28T23:52:15.000Z

2020-04-29T05:58:46.000Z

examples/node2vec_wiki.py

1172939260/GE

df8bc2bb514b4f890764c26f3d36fad4c99de1cc

[ "MIT" ]

null

examples/node2vec_wiki.py

1172939260/GE

df8bc2bb514b4f890764c26f3d36fad4c99de1cc

[ "MIT" ]

null

import numpy as np from ge.classify import read_node_label, Classifier from ge import Node2Vec from sklearn.linear_model import LogisticRegression import matplotlib.pyplot as plt import networkx as nx from sklearn.manifold import TSNE def evaluate_embeddings(embeddings): X, Y = read_node_label('../data/wiki/wiki_labels.txt') tr_frac = 0.8 print("Training classifier using {:.2f}% nodes...".format( tr_frac * 100)) clf = Classifier(embeddings=embeddings, clf=LogisticRegression()) clf.split_train_evaluate(X, Y, tr_frac) def plot_embeddings(embeddings,): X, Y = read_node_label('../data/wiki/wiki_labels.txt') emb_list = [] for k in X: emb_list.append(embeddings[k]) emb_list = np.array(emb_list) model = TSNE(n_components=2) node_pos = model.fit_transform(emb_list) color_idx = {} for i in range(len(X)): color_idx.setdefault(Y[i][0], []) color_idx[Y[i][0]].append(i) for c, idx in color_idx.items(): plt.scatter(node_pos[idx, 0], node_pos[idx, 1], label=c)) plt.legend() plt.show() if __name__ == "__main__": G=nx.read_edgelist('../data/wiki/Wiki_edgelist.txt', create_using = nx.DiGraph(), nodetype = None, data = [('weight', int)]) model=Node2Vec(G, walk_length = 10, num_walks = 80, p = 0.25, q = 4, workers = 1) model.train(window_size = 5, iter = 3) embeddings=model.get_embeddings() evaluate_embeddings(embeddings) plot_embeddings(embeddings)

27.981818

96

0.658869

import numpy as np from ge.classify import read_node_label, Classifier from ge import Node2Vec from sklearn.linear_model import LogisticRegression import matplotlib.pyplot as plt import networkx as nx from sklearn.manifold import TSNE def evaluate_embeddings(embeddings): X, Y = read_node_label('../data/wiki/wiki_labels.txt') tr_frac = 0.8 print("Training classifier using {:.2f}% nodes...".format( tr_frac * 100)) clf = Classifier(embeddings=embeddings, clf=LogisticRegression()) clf.split_train_evaluate(X, Y, tr_frac) def plot_embeddings(embeddings,): X, Y = read_node_label('../data/wiki/wiki_labels.txt') emb_list = [] for k in X: emb_list.append(embeddings[k]) emb_list = np.array(emb_list) model = TSNE(n_components=2) node_pos = model.fit_transform(emb_list) color_idx = {} for i in range(len(X)): color_idx.setdefault(Y[i][0], []) color_idx[Y[i][0]].append(i) for c, idx in color_idx.items(): plt.scatter(node_pos[idx, 0], node_pos[idx, 1], label=c)) plt.legend() plt.show() if __name__ == "__main__": G=nx.read_edgelist('../data/wiki/Wiki_edgelist.txt', create_using = nx.DiGraph(), nodetype = None, data = [('weight', int)]) model=Node2Vec(G, walk_length = 10, num_walks = 80, p = 0.25, q = 4, workers = 1) model.train(window_size = 5, iter = 3) embeddings=model.get_embeddings() evaluate_embeddings(embeddings) plot_embeddings(embeddings)

false

true

f71312d595a0b97bd875bad604a1adfa9e461df1

652

py

Python

runs/src2-tgt1/seq-bro-iter10000.cfg.py

janpawellek/broeval

57e31aa6e354d0bba88103b44910483e8d982d00

[ "MIT" ]

null

runs/src2-tgt1/seq-bro-iter10000.cfg.py

janpawellek/broeval

57e31aa6e354d0bba88103b44910483e8d982d00

[ "MIT" ]

null

runs/src2-tgt1/seq-bro-iter10000.cfg.py

janpawellek/broeval

57e31aa6e354d0bba88103b44910483e8d982d00

[ "MIT" ]

null

# Write results to this file OUTFILE = 'runs/src2-tgt1/seq-bro-iter10000.result.csv' # Source computers for the requests SOURCE = ['10.0.0.1', '10.0.0.3'] # Should Bro be enabled on the source machines? SOURCE_BRO = [True, True] # Target machines for the requests (aka server) TARGET = ['10.0.0.2'] # Should Bro be enabled on the target machines? TARGET_BRO = [True] # Connection mode (par = parallel, seq = sequential) MODE = 'seq' # Number of evaluation repetitions to run EPOCHS = 100 # Number of iterations to be run in each evaluation repetition ITER = 10000 # Size of the file to be downloaded from target (in Bytes * 10^SIZE) SIZE = 5

22.482759

68

0.716258

OUTFILE = 'runs/src2-tgt1/seq-bro-iter10000.result.csv' SOURCE = ['10.0.0.1', '10.0.0.3'] SOURCE_BRO = [True, True] TARGET = ['10.0.0.2'] TARGET_BRO = [True] MODE = 'seq' EPOCHS = 100 ITER = 10000 SIZE = 5

true

f713157fa8e0a5fb64ac7dc684b4acc75edad6c4

1,467

py

Python

riptable/tests/test_scalar.py

972d5defe3218bd62b741e6a2f11f5b3/riptable

bb928c11752e831ec701f91964979b31db53826a

[ "BSD-2-Clause-Patent" ]

307

2020-08-27T20:25:11.000Z

2022-03-08T15:51:19.000Z

riptable/tests/test_scalar.py

972d5defe3218bd62b741e6a2f11f5b3/riptable

bb928c11752e831ec701f91964979b31db53826a

[ "BSD-2-Clause-Patent" ]

206

2020-08-17T19:07:15.000Z

2022-03-18T11:53:55.000Z

riptable/tests/test_scalar.py

972d5defe3218bd62b741e6a2f11f5b3/riptable

bb928c11752e831ec701f91964979b31db53826a

[ "BSD-2-Clause-Patent" ]

10

2020-08-28T00:22:05.000Z

2021-04-30T20:22:28.000Z

"""Test around scalar constructors and scalar methods.""" import riptable as rt import numpy as np import pytest from numpy.testing import assert_almost_equal, assert_warns class TestScalarConstructor(object): # Type-coercion from strings test cases adapted from numpy/core/tests/test_scalar_ctors.py. # https://github.com/numpy/numpy/blob/c31cc36a8a814ed4844a2a553454185601914a5a/numpy/core/tests/test_scalar_ctors.py @pytest.mark.parametrize( "scalar_ctor, numeric_string", [ # simple numeric string ("single", "1.234"), ("double", "1.234"), ("longdouble", "1.234"), # numeric string with overflow overflow; expect inf value ("half", "1e10000"), ("single", "1e10000"), ("double", "1e10000"), ("longdouble", "1e10000"), ("longdouble", "-1e10000"), ], ) def test_floating(self, scalar_ctor, numeric_string): rt_value = getattr(rt, scalar_ctor)(numeric_string) np_value = getattr(np, scalar_ctor)(numeric_string) assert_almost_equal(rt_value, np_value) @pytest.mark.parametrize( "scalar_ctor, numeric_string", [("longdouble", "1e10000"), ("longdouble", "-1e10000"),], ) def test_overflow_warning(self, scalar_ctor, numeric_string): assert_warns(RuntimeWarning, getattr(np, scalar_ctor), numeric_string)

38.605263

121

0.630539

import riptable as rt import numpy as np import pytest from numpy.testing import assert_almost_equal, assert_warns class TestScalarConstructor(object): @pytest.mark.parametrize( "scalar_ctor, numeric_string", [ ("single", "1.234"), ("double", "1.234"), ("longdouble", "1.234"), ("half", "1e10000"), ("single", "1e10000"), ("double", "1e10000"), ("longdouble", "1e10000"), ("longdouble", "-1e10000"), ], ) def test_floating(self, scalar_ctor, numeric_string): rt_value = getattr(rt, scalar_ctor)(numeric_string) np_value = getattr(np, scalar_ctor)(numeric_string) assert_almost_equal(rt_value, np_value) @pytest.mark.parametrize( "scalar_ctor, numeric_string", [("longdouble", "1e10000"), ("longdouble", "-1e10000"),], ) def test_overflow_warning(self, scalar_ctor, numeric_string): assert_warns(RuntimeWarning, getattr(np, scalar_ctor), numeric_string)

true

f71315f272ca0635af315b2525f676576c7255ad

8,680

py

Python

src/biokbase/narrative/jobs/specmanager.py

jmchandonia/narrative

13895904956b31f2d51440d94473cd05ecca1e60

[ "MIT" ]

null

src/biokbase/narrative/jobs/specmanager.py

jmchandonia/narrative

13895904956b31f2d51440d94473cd05ecca1e60

[ "MIT" ]

null

src/biokbase/narrative/jobs/specmanager.py

jmchandonia/narrative

13895904956b31f2d51440d94473cd05ecca1e60

[ "MIT" ]

null

import biokbase.narrative.clients as clients from biokbase.narrative.app_util import ( app_version_tags, check_tag, app_param ) import json from jinja2 import Template from IPython.display import HTML class SpecManager(object): __instance = None app_specs = dict() type_specs = dict() def __new__(cls): if SpecManager.__instance is None: SpecManager.__instance = object.__new__(cls) SpecManager.__instance.reload() return SpecManager.__instance def get_spec(self, app_id, tag='release'): self.check_app(app_id, tag, raise_exception=True) return self.app_specs[tag][app_id] def get_type_spec(self, type_id, raise_exception=True): if (type_id not in self.type_specs) and raise_exception: raise ValueError('Unknown type id "{}"'.format(type_id)) return self.type_specs.get(type_id) def reload(self): """ Reloads all app specs into memory from the latest update. """ client = clients.get('narrative_method_store') for tag in app_version_tags: specs = client.list_methods_spec({'tag': tag}) spec_dict = dict() for spec in specs: spec_dict[spec['info']['id']] = spec self.app_specs[tag] = spec_dict # And let's load all types from the beginning and cache them self.type_specs = client.list_categories({'load_types': 1})[3] def app_description(self, app_id, tag='release'): """ Returns the app description as a printable object. Makes it kinda pretty? repr_html, maybe? """ self.check_app(app_id, tag, raise_exception=True) info = clients.get('narrative_method_store').get_method_full_info({'ids': [app_id], 'tag': tag})[0] tmpl = """ <div class="bg-info" style="padding:15px"> <h1>{{info.name}} <small>{{info.module_name}}</small></h1> <p class='lead'>{{info.id}} - v{{info.ver}}</p> </div> <p class='lead'>{{info.subtitle}}</p> <hr> {{info.description}} """ return HTML(Template(tmpl).render(info=info)) def available_apps(self, tag="release"): """ Lists the set of available apps in a pretty HTML way. Usable only in the Jupyter notebook. """ check_tag(tag, raise_exception=True) tmpl=""" <b>Available {{tag}} apps</b><br> <table class="table table-striped table-bordered table-condensed"> <thead> <tr> <th>Id</th> <th>Name</th> <th>Subtitle</th> </tr> </thead> {% for m in apps %} <tr> <td> {{ m.info.id }} </td> <td> {{ m.info.name }} </td> <td> {{ m.info.subtitle }} </td> </tr> {% endfor %} </table> """ return HTML(Template(tmpl).render(tag=tag, apps=sorted(list(self.app_specs[tag].values()), key=lambda m: m['info']['id']))) def app_usage(self, app_id, tag='release'): """ Should show app inputs and outputs. Something like this: App id App name Subtitle Parameters 1. xxx - string - data object - [type1, type2, type3] (subtitle, description, etc) 2. yyy - int - from x to y (subtitle, description, etc) 3. zzz - list of strings ... 4. aaa - OUTPUT - .... """ self.check_app(app_id, tag, raise_exception=True) spec = self.app_specs[tag][app_id] # start with basic info usage = {'id': app_id, 'name': spec['info']['name'], 'tag': tag, 'subtitle': spec['info']['subtitle'], 'ver': spec['info']['ver'], 'params': self.app_params(spec)} return AppUsage(usage) def check_app(self, app_id, tag='release', raise_exception=False): """ Checks if a method (and release tag) is available for running and such. If raise_exception==True, and either the tag or app_id are invalid, a ValueError is raised. If raise_exception==False, and there's something invalid, it just returns False. If everything is hunky-dory, it returns True. """ tag_ok = check_tag(tag, raise_exception=raise_exception) if not tag_ok: return False if app_id not in self.app_specs[tag]: if raise_exception: raise ValueError('Unknown app id "{}" tagged as "{}"'.format(app_id, tag)) return False return True def app_params(self, spec): """ Should return a dict of params with key = id, val = { optional = boolean, is_constant = boolean, value = (whatever, optional), type = [text|int|float|list], is_output = boolean, short_hint = string, description = string, allowed_values = list (optional), } """ params = list() for p in spec['parameters']: p_info = app_param(p) params.append(p_info) for p in spec.get('parameter_groups', []): p_info = {'id': p.get('id', ''), 'is_group': True} p_info['optional'] = p.get('optional', 0) == 1 p_info['short_hint'] = p.get('short_hint', '') p_info['description'] = p.get('ui_name', '') p_info['parameter_ids'] = p.get('parameter_ids', []) p_info['id_mapping'] = p.get('id_mapping', {}) p_info['allow_multiple'] = p.get('allow_multiple', 0) p_info['type'] = 'group' params.append(p_info) return sorted(params, key=lambda p: (p.get('optional', False), p.get('is_output', False))) class AppUsage(object): """ A tiny class for representing app usage in HTML (or as a pretty string) """ def __init__(self, usage): self.usage = usage def _repr_html_(self): tmpl = """ <h1>{{usage.name}}</h1> id = {{usage.id}}<br> {{usage.subtitle}}<br> Parameters (<span class="bg-warning">required</span>) <table class="table table-striped table-bordered table-condensed"> <thead> <tr> <th>Id</th> <th>Type</th> <th>Allowed Types</th> <th>Description</th> <th>Allowed Values</th> <th>Default</th> </tr> </thead> {% for p in usage.params %} <tr {% if not p.optional %}class="warning"{% endif %}> <td>{{ p.id|e }}</td> <td>{{ p.type|e }}{% if p.is_output %} (output){% endif %}</td> <td> {% if p.allowed_types %} {% for t in p.allowed_types %} {{t}}<br> {% endfor %} {% else %} N/A {% endif %} </td> <td>{{ p.short_hint|e }}</td> <td> {% if p.allowed_values %} {% for v in p.allowed_values %} {{v}}<br> {% endfor %} {% else %} N/A {% endif %} </td> <td> {% if p.default %} {{ p.default }} {% endif %} </tr> {% endfor %} </table> """ return Template(tmpl).render(usage=self.usage) # return "<h1>" + self.usage['name'] + "</h1>" + self.usage['id'] + "<br>" def __repr__(self): return self.__str__() def __str__(self): s = "id: {}\nname: {}\nsubtitle: {}\nparameters (*required):\n-----------------------".format(self.usage['id'], self.usage['name'], self.usage['subtitle']) for p in self.usage['params']: if not p.get("is_constant", False): p_def = "\n{}{} - {}".format('*' if not p['optional'] else '', p['id'], p['type']) if "allowed_types" in p: p_def = p_def + " - is a data object where the type is one of: {}".format(json.dumps(p['allowed_types'])) if "allowed_values" in p: p_def = p_def + " - must be one of {}".format(json.dumps(p['allowed_values'])) s = s + p_def return s

33.003802

163

0.501152

import biokbase.narrative.clients as clients from biokbase.narrative.app_util import ( app_version_tags, check_tag, app_param ) import json from jinja2 import Template from IPython.display import HTML class SpecManager(object): __instance = None app_specs = dict() type_specs = dict() def __new__(cls): if SpecManager.__instance is None: SpecManager.__instance = object.__new__(cls) SpecManager.__instance.reload() return SpecManager.__instance def get_spec(self, app_id, tag='release'): self.check_app(app_id, tag, raise_exception=True) return self.app_specs[tag][app_id] def get_type_spec(self, type_id, raise_exception=True): if (type_id not in self.type_specs) and raise_exception: raise ValueError('Unknown type id "{}"'.format(type_id)) return self.type_specs.get(type_id) def reload(self): client = clients.get('narrative_method_store') for tag in app_version_tags: specs = client.list_methods_spec({'tag': tag}) spec_dict = dict() for spec in specs: spec_dict[spec['info']['id']] = spec self.app_specs[tag] = spec_dict self.type_specs = client.list_categories({'load_types': 1})[3] def app_description(self, app_id, tag='release'): self.check_app(app_id, tag, raise_exception=True) info = clients.get('narrative_method_store').get_method_full_info({'ids': [app_id], 'tag': tag})[0] tmpl = """ <div class="bg-info" style="padding:15px"> <h1>{{info.name}} <small>{{info.module_name}}</small></h1> <p class='lead'>{{info.id}} - v{{info.ver}}</p> </div> <p class='lead'>{{info.subtitle}}</p> <hr> {{info.description}} """ return HTML(Template(tmpl).render(info=info)) def available_apps(self, tag="release"): check_tag(tag, raise_exception=True) tmpl=""" <b>Available {{tag}} apps</b><br> <table class="table table-striped table-bordered table-condensed"> <thead> <tr> <th>Id</th> <th>Name</th> <th>Subtitle</th> </tr> </thead> {% for m in apps %} <tr> <td> {{ m.info.id }} </td> <td> {{ m.info.name }} </td> <td> {{ m.info.subtitle }} </td> </tr> {% endfor %} </table> """ return HTML(Template(tmpl).render(tag=tag, apps=sorted(list(self.app_specs[tag].values()), key=lambda m: m['info']['id']))) def app_usage(self, app_id, tag='release'): self.check_app(app_id, tag, raise_exception=True) spec = self.app_specs[tag][app_id] # start with basic info usage = {'id': app_id, 'name': spec['info']['name'], 'tag': tag, 'subtitle': spec['info']['subtitle'], 'ver': spec['info']['ver'], 'params': self.app_params(spec)} return AppUsage(usage) def check_app(self, app_id, tag='release', raise_exception=False): tag_ok = check_tag(tag, raise_exception=raise_exception) if not tag_ok: return False if app_id not in self.app_specs[tag]: if raise_exception: raise ValueError('Unknown app id "{}" tagged as "{}"'.format(app_id, tag)) return False return True def app_params(self, spec): params = list() for p in spec['parameters']: p_info = app_param(p) params.append(p_info) for p in spec.get('parameter_groups', []): p_info = {'id': p.get('id', ''), 'is_group': True} p_info['optional'] = p.get('optional', 0) == 1 p_info['short_hint'] = p.get('short_hint', '') p_info['description'] = p.get('ui_name', '') p_info['parameter_ids'] = p.get('parameter_ids', []) p_info['id_mapping'] = p.get('id_mapping', {}) p_info['allow_multiple'] = p.get('allow_multiple', 0) p_info['type'] = 'group' params.append(p_info) return sorted(params, key=lambda p: (p.get('optional', False), p.get('is_output', False))) class AppUsage(object): def __init__(self, usage): self.usage = usage def _repr_html_(self): tmpl = """ <h1>{{usage.name}}</h1> id = {{usage.id}}<br> {{usage.subtitle}}<br> Parameters (<span class="bg-warning">required</span>) <table class="table table-striped table-bordered table-condensed"> <thead> <tr> <th>Id</th> <th>Type</th> <th>Allowed Types</th> <th>Description</th> <th>Allowed Values</th> <th>Default</th> </tr> </thead> {% for p in usage.params %} <tr {% if not p.optional %}class="warning"{% endif %}> <td>{{ p.id|e }}</td> <td>{{ p.type|e }}{% if p.is_output %} (output){% endif %}</td> <td> {% if p.allowed_types %} {% for t in p.allowed_types %} {{t}}<br> {% endfor %} {% else %} N/A {% endif %} </td> <td>{{ p.short_hint|e }}</td> <td> {% if p.allowed_values %} {% for v in p.allowed_values %} {{v}}<br> {% endfor %} {% else %} N/A {% endif %} </td> <td> {% if p.default %} {{ p.default }} {% endif %} </tr> {% endfor %} </table> """ return Template(tmpl).render(usage=self.usage) # return "<h1>" + self.usage['name'] + "</h1>" + self.usage['id'] + "<br>" def __repr__(self): return self.__str__() def __str__(self): s = "id: {}\nname: {}\nsubtitle: {}\nparameters (*required):\n-----------------------".format(self.usage['id'], self.usage['name'], self.usage['subtitle']) for p in self.usage['params']: if not p.get("is_constant", False): p_def = "\n{}{} - {}".format('*' if not p['optional'] else '', p['id'], p['type']) if "allowed_types" in p: p_def = p_def + " - is a data object where the type is one of: {}".format(json.dumps(p['allowed_types'])) if "allowed_values" in p: p_def = p_def + " - must be one of {}".format(json.dumps(p['allowed_values'])) s = s + p_def return s

true

f713161df41c6eba642808b055946fa7241ef5ba

397

py

Python

digits/dataset/tasks/__init__.py

ojmakhura/DIGITS

f34e62c245054b51ea51fcb8949d2ca777f162d1

[ "BSD-3-Clause" ]

null

digits/dataset/tasks/__init__.py

ojmakhura/DIGITS

f34e62c245054b51ea51fcb8949d2ca777f162d1

[ "BSD-3-Clause" ]

null

digits/dataset/tasks/__init__.py

ojmakhura/DIGITS

f34e62c245054b51ea51fcb8949d2ca777f162d1

[ "BSD-3-Clause" ]

null

# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from .analyze_db import AnalyzeDbTask from .create_db import CreateDbTask from .create_generic_db import CreateGenericDbTask from .parse_folder import ParseFolderTask from .parse_s3 import ParseS3Task __all__ = [ 'AnalyzeDbTask', 'CreateDbTask', 'CreateGenericDbTask', 'ParseFolderTask', 'ParseS3Task', ]

23.352941

68

0.768262

from .analyze_db import AnalyzeDbTask from .create_db import CreateDbTask from .create_generic_db import CreateGenericDbTask from .parse_folder import ParseFolderTask from .parse_s3 import ParseS3Task __all__ = [ 'AnalyzeDbTask', 'CreateDbTask', 'CreateGenericDbTask', 'ParseFolderTask', 'ParseS3Task', ]

true

f713163dddd2cb0d284f77fcefb7c00d732eeea7

23,328

py

Python

test/programytest/test_bot.py

motazsaad/fit-bot-fb-clt

580477aa1ec91855b621d9ae276f2705962f6a87

[ "MIT" ]

null

test/programytest/test_bot.py

motazsaad/fit-bot-fb-clt

580477aa1ec91855b621d9ae276f2705962f6a87

[ "MIT" ]

null

test/programytest/test_bot.py

motazsaad/fit-bot-fb-clt

580477aa1ec91855b621d9ae276f2705962f6a87

[ "MIT" ]

4

2019-04-01T15:42:23.000Z

2020-11-05T08:14:27.000Z

import unittest.mock from programy.brain import Brain from programy.bot import BrainFactory from programy.bot import Bot from programy.config.bot.bot import BotConfiguration from programy.config.programy import ProgramyConfiguration from programy.clients.events.console.config import ConsoleConfiguration from programy.context import ClientContext from programy.config.bot.spelling import BotSpellingConfiguration from programytest.client import TestClient class MockBrain(Brain): def __init__(self, bot, configuration): Brain.__init__(self, bot, configuration) self._response = "" def ask_question(self, clientid, sentence, srai=False): return self._response class MockBot(Bot): def __init__(self, config: BotConfiguration, client): Bot.__init__(self, config, client) def loads_brains(self, bot): self._brains["mock"] = MockBrain(self, self.configuration.configurations[0]) class BrainFactoryTests(unittest.TestCase): def test_empty_config_init(self): configuration = BotConfiguration() configuration._bot_selector = "programy.clients.client.DefaultBrainSelector" client = TestClient() bot = Bot(configuration, client) factory = BrainFactory(bot) self.assertIsNotNone(factory) brain = factory.select_brain() self.assertIsNotNone(brain) self.assertIsInstance(brain, Brain) class BotTests(unittest.TestCase): def setUp(self): client = TestClient() self._client_context = client.create_client_context("testid") def test_bot_init_blank(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot.brain) self.assertEqual("bot", bot.ylogger_type()) self.assertIsNone(bot.spell_checker) self.assertIsNotNone(bot.sentence_splitter) self.assertIsNotNone(bot.sentence_joiner) self.assertIsNotNone(bot.conversations) self.assertIsNotNone(bot.default_response) self.assertIsNotNone(bot.exit_response) self.assertIsNotNone(bot.initial_question) self.assertTrue(bot.override_properties) self.assertIsNotNone(bot.get_version_string) def test_bot_init_with_config(self): bot_config = BotConfiguration() bot_config._bot_root = BotConfiguration.DEFAULT_ROOT bot_config._default_response = BotConfiguration.DEFAULT_RESPONSE bot_config._exit_response = BotConfiguration.DEFAULT_EXIT_RESPONSE bot_config._initial_question = BotConfiguration.DEFAULT_INITIAL_QUESTION bot_config._empty_string = BotConfiguration.DEFAULT_EMPTY_STRING bot_config._override_properties = BotConfiguration.DEFAULT_OVERRIDE_PREDICATES bot_config._max_question_recursion = 1000 bot_config._max_question_timeout = 60 bot_config._max_search_depth = 100 bot_config._max_search_timeout = 60 client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot.brain) self.assertIsNone(bot.spell_checker) self.assertIsNotNone(bot.sentence_splitter) self.assertIsNotNone(bot.sentence_joiner) self.assertIsNotNone(bot.conversations) self.assertIsNotNone(bot.default_response) self.assertIsNotNone(bot.exit_response) self.assertIsNotNone(bot.initial_question) self.assertTrue(bot.override_properties) self.assertIsNotNone(bot.get_version_string) def test_bot_old_version(self): bot_config = BotConfiguration() client = TestClient() bot = Bot(bot_config, client) self._client_context.brain.properties.add_property("name", 'bot'), self._client_context.brain.properties.add_property("version", "1.9.3"), self._client_context.brain.properties.add_property("birthdate", "1st January 2019") version = bot.get_version_string(self._client_context) self.assertIsNotNone(version) self.assertEqual("bot, v1.9.3, initiated 1st January 2019", version) def test_bot_new_version(self): bot_config = BotConfiguration() client = TestClient() bot = Bot(bot_config, client) self._client_context.brain.properties.add_property("name", 'bot'), self._client_context.brain.properties.add_property("app_version", "1.9.3"), self._client_context.brain.properties.add_property("grammar_version", "37"), self._client_context.brain.properties.add_property("birthdate", "1st January 2019") version = bot.get_version_string(self._client_context) self.assertIsNotNone(version) self.assertEqual("bot, App: v1.9.3 Grammar v37, initiated 1st January 2019", version) def test_bot_init_no_spellchecker_configuration(self): bot_config = BotConfiguration() bot_config._spelling = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.spell_checker) def test_bot_init_no_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.spell_checker) def test_bot_init_with_invalid_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.spell_checker) def test_bot_init_with_valid_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = "programy.spelling.textblob_spelling.TextBlobSpellingChecker" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.spell_checker) def test_bot_init_no_splitter_configuration(self): bot_config = BotConfiguration() bot_config._splitter = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_splitter) def test_bot_init_no_splitterr(self): bot_config = BotConfiguration() bot_config.splitter._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_splitter) def test_bot_init_with_invalid_splitterr(self): bot_config = BotConfiguration() bot_config.splitter._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_splitter) def test_bot_init_with_valid_splitterr(self): bot_config = BotConfiguration() bot_config.splitter._classname = "programy.dialog.splitter.splitter.SentenceSplitter" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.sentence_splitter) def test_bot_init_no_joiner_configuration(self): bot_config = BotConfiguration() bot_config._joiner = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_joiner) def test_bot_init_no_joinerr(self): bot_config = BotConfiguration() bot_config.joiner._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_joiner) def test_bot_init_with_invalid_joinerr(self): bot_config = BotConfiguration() bot_config.joiner._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_joiner) def test_bot_init_with_valid_joinerr(self): bot_config = BotConfiguration() bot_config.joiner._classname = "programy.dialog.joiner.joiner.SentenceJoiner" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.sentence_joiner) def test_bot_init_no_translator_configuration(self): bot_config = BotConfiguration() bot_config._from_translator = None bot_config._to_translator = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.from_translator) self.assertIsNone(bot.to_translator) def test_bot_init_no_translatorr(self): bot_config = BotConfiguration() bot_config.from_translator._classname = None bot_config.to_translator._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.from_translator) self.assertIsNone(bot.to_translator) def test_bot_init_with_invalid_translatorr(self): bot_config = BotConfiguration() bot_config.from_translator._classname = "programy.spelling.checker.SpellingCheckerX" bot_config.to_translator._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.from_translator) self.assertIsNone(bot.to_translator) def test_bot_init_with_valid_translatorr(self): bot_config = BotConfiguration() bot_config.from_translator._classname = "programy.translate.textblob_translator.TextBlobTranslator" bot_config.to_translator._classname = "programy.translate.textblob_translator.TextBlobTranslator" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.from_translator) self.assertIsNotNone(bot.to_translator) def test_bot_init_no_sentiment_analyser_configuration(self): bot_config = BotConfiguration() bot_config._sentiment = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentiment_analyser) def test_bot_init_no_sentiment_analyserr(self): bot_config = BotConfiguration() bot_config.sentiment_analyser._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentiment_analyser) def test_bot_init_with_invalid_sentiment_analyserr(self): bot_config = BotConfiguration() bot_config.sentiment_analyser._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentiment_analyser) def test_bot_init_with_valid_sentiment_analyserr(self): bot_config = BotConfiguration() bot_config.sentiment_analyser._classname = "programy.sentiment.textblob_sentiment.TextBlobSentimentAnalyser" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.sentiment_analyser) def test_bot_init_default_brain(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.brain) def test_bot_init_supplied_brain(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.brain) def test_bot_defaultresponses(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertEqual(bot.default_response, "") self.assertEqual(bot.exit_response, "Bye!") def test_bot_with_config(self): configuration = ProgramyConfiguration(ConsoleConfiguration()) self.assertIsNotNone(configuration) self.assertIsNotNone(configuration.client_configuration.configurations[0]) self.assertIsNotNone(configuration.client_configuration.configurations[0].configurations[0]) configuration.client_configuration.configurations[0].prompt = ":" configuration.client_configuration.configurations[0].default_response = "No answer for that" configuration.client_configuration.configurations[0].exit_response = "See ya!" client = TestClient() bot = Bot(configuration.client_configuration.configurations[0], client) self.assertIsNotNone(bot) self.assertEqual(bot.default_response, "No answer for that") self.assertEqual(bot.exit_response, "See ya!") def test_bot_with_conversation(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertFalse(bot.has_conversation(self._client_context)) response = bot.ask_question(self._client_context, "hello") self.assertIsNotNone(response) self.assertTrue(bot.has_conversation(self._client_context)) response = bot.ask_question(self._client_context, "hello") self.assertIsNotNone(response) self.assertTrue(bot.has_conversation(self._client_context)) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = self._client_context.bot.brain response = bot.ask_question(client_context2, "hello") self.assertIsNotNone(response) self.assertTrue(bot.has_conversation(client_context2)) def test_bot_chat_loop(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertIsInstance(bot, Bot) bot.configuration._default_response = "Sorry, I don't have an answer for that right now" response = bot.ask_question(self._client_context, "hello") self.assertIsNotNone(response) self.assertEqual(response, "Sorry, I don't have an answer for that right now.") response = bot.ask_question(self._client_context, "hello again") self.assertIsNotNone(response) self.assertEqual(response, "Sorry, I don't have an answer for that right now.") response = bot.ask_question(self._client_context, "goodbye") self.assertIsNotNone(response) self.assertEqual(response, "Sorry, I don't have an answer for that right now.") conversation = bot.get_conversation(self._client_context) self.assertIsNotNone(conversation) self.assertEqual(conversation.previous_nth_question(2).sentence(0).text(), "hello") self.assertEqual(conversation.previous_nth_question(2).sentence(0).response, "Sorry, I don't have an answer for that right now") self.assertEqual(conversation.previous_nth_question(1).sentence(0).text(), "hello again") self.assertEqual(conversation.previous_nth_question(1).sentence(0).response, "Sorry, I don't have an answer for that right now") self.assertEqual(conversation.previous_nth_question(0).sentence(0).text(), "goodbye") self.assertEqual(conversation.previous_nth_question(0).sentence(0).response, "Sorry, I don't have an answer for that right now") def test_max_recusion(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) bot.configuration._default_response = "Sorry, I don't have an answer for that right now" bot.configuration._max_question_recursion = 0 with self.assertRaises(Exception): bot.ask_question(self._client_context, "hello") def test_get_default_response_empty_string(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("", bot.get_default_response(self._client_context)) def test_get_default_response_default_response_only(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.default_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_default_response(self._client_context)) def test_get_default_response_default_response_srai_no_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.default_response_srai = "YDEFAULTRESPONSE" bot_config.default_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_default_response(self._client_context)) def test_get_default_response_default_response_srai_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.default_response_srai = "YDEFAULTRESPONSE" bot_config.default_response = "Default response!" client = TestClient() bot = MockBot(bot_config, client) self.assertIsNotNone(bot) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = MockBrain(bot, bot.configuration.configurations[0]) client_context2._brain._response = "Y DEFAULT RESPONSE" response = bot.get_default_response(client_context2) self.assertIsNotNone(response) self.assertEqual("Y DEFAULT RESPONSE", response) def test_get_default_response_no_srai(self): bot_config = BotConfiguration() bot_config._default_response_srai = None bot_config._default_response = "Test This" self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Test This", bot.get_default_response(self._client_context)) def test_get_initial_question_empty_string(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Hello", bot.get_initial_question(self._client_context)) def test_get_initial_question_initial_question_only(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.initial_question = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_initial_question(self._client_context)) def test_get_initial_question_initial_question_srai_no_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.initial_question_srai = "YDEFAULTRESPONSE" bot_config.initial_question = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_initial_question(self._client_context)) def test_get_initial_question_initial_question_srai_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = MockBot(bot_config, client) self.assertIsNotNone(bot) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = MockBrain(bot, bot.configuration.configurations[0]) client_context2._brain._response = "Y DEFAULT RESPONSE" self.assertEqual("Y DEFAULT RESPONSE", bot.get_initial_question(client_context2)) def test_get_initial_question_no_srai(self): bot_config = BotConfiguration() bot_config._initial_question = "Test This" bot_config._initial_question_srai = None self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Test This", bot.get_initial_question(self._client_context)) def test_get_exit_response_empty_string(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Bye!", bot.get_exit_response(self._client_context)) def test_get_exit_response_exit_response_only(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.exit_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_exit_response(self._client_context)) def test_get_exit_response_exit_response_srai_no_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.exit_response_srai = "YDEFAULTRESPONSE" bot_config.exit_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_exit_response(self._client_context)) def test_get_exit_response_exit_response_srai_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.exit_response_srai = "YDEFAULTRESPONSE" bot_config.exit_response = "Default response!" client = TestClient() bot = MockBot(bot_config, client) self.assertIsNotNone(bot) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = MockBrain(bot, bot.configuration.configurations[0]) client_context2._brain._response = "Y DEFAULT RESPONSE" self.assertEqual("Y DEFAULT RESPONSE", bot.get_exit_response(client_context2)) def test_get_exit_response_no_srai(self): bot_config = BotConfiguration() bot_config._exit_response = "Test This" bot_config._exit_response_srai = None self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Test This", bot.get_exit_response(self._client_context)) def test_log_answer(self): bot_config = BotConfiguration() client = TestClient() bot = Bot(bot_config, client) bot.log_answer(self._client_context, "Hello", "Test", None) response_logger = unittest.mock.Mock() bot.log_answer(self._client_context, "Hello", "Test", response_logger)

36.223602

136

0.70126

import unittest.mock from programy.brain import Brain from programy.bot import BrainFactory from programy.bot import Bot from programy.config.bot.bot import BotConfiguration from programy.config.programy import ProgramyConfiguration from programy.clients.events.console.config import ConsoleConfiguration from programy.context import ClientContext from programy.config.bot.spelling import BotSpellingConfiguration from programytest.client import TestClient class MockBrain(Brain): def __init__(self, bot, configuration): Brain.__init__(self, bot, configuration) self._response = "" def ask_question(self, clientid, sentence, srai=False): return self._response class MockBot(Bot): def __init__(self, config: BotConfiguration, client): Bot.__init__(self, config, client) def loads_brains(self, bot): self._brains["mock"] = MockBrain(self, self.configuration.configurations[0]) class BrainFactoryTests(unittest.TestCase): def test_empty_config_init(self): configuration = BotConfiguration() configuration._bot_selector = "programy.clients.client.DefaultBrainSelector" client = TestClient() bot = Bot(configuration, client) factory = BrainFactory(bot) self.assertIsNotNone(factory) brain = factory.select_brain() self.assertIsNotNone(brain) self.assertIsInstance(brain, Brain) class BotTests(unittest.TestCase): def setUp(self): client = TestClient() self._client_context = client.create_client_context("testid") def test_bot_init_blank(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot.brain) self.assertEqual("bot", bot.ylogger_type()) self.assertIsNone(bot.spell_checker) self.assertIsNotNone(bot.sentence_splitter) self.assertIsNotNone(bot.sentence_joiner) self.assertIsNotNone(bot.conversations) self.assertIsNotNone(bot.default_response) self.assertIsNotNone(bot.exit_response) self.assertIsNotNone(bot.initial_question) self.assertTrue(bot.override_properties) self.assertIsNotNone(bot.get_version_string) def test_bot_init_with_config(self): bot_config = BotConfiguration() bot_config._bot_root = BotConfiguration.DEFAULT_ROOT bot_config._default_response = BotConfiguration.DEFAULT_RESPONSE bot_config._exit_response = BotConfiguration.DEFAULT_EXIT_RESPONSE bot_config._initial_question = BotConfiguration.DEFAULT_INITIAL_QUESTION bot_config._empty_string = BotConfiguration.DEFAULT_EMPTY_STRING bot_config._override_properties = BotConfiguration.DEFAULT_OVERRIDE_PREDICATES bot_config._max_question_recursion = 1000 bot_config._max_question_timeout = 60 bot_config._max_search_depth = 100 bot_config._max_search_timeout = 60 client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot.brain) self.assertIsNone(bot.spell_checker) self.assertIsNotNone(bot.sentence_splitter) self.assertIsNotNone(bot.sentence_joiner) self.assertIsNotNone(bot.conversations) self.assertIsNotNone(bot.default_response) self.assertIsNotNone(bot.exit_response) self.assertIsNotNone(bot.initial_question) self.assertTrue(bot.override_properties) self.assertIsNotNone(bot.get_version_string) def test_bot_old_version(self): bot_config = BotConfiguration() client = TestClient() bot = Bot(bot_config, client) self._client_context.brain.properties.add_property("name", 'bot'), self._client_context.brain.properties.add_property("version", "1.9.3"), self._client_context.brain.properties.add_property("birthdate", "1st January 2019") version = bot.get_version_string(self._client_context) self.assertIsNotNone(version) self.assertEqual("bot, v1.9.3, initiated 1st January 2019", version) def test_bot_new_version(self): bot_config = BotConfiguration() client = TestClient() bot = Bot(bot_config, client) self._client_context.brain.properties.add_property("name", 'bot'), self._client_context.brain.properties.add_property("app_version", "1.9.3"), self._client_context.brain.properties.add_property("grammar_version", "37"), self._client_context.brain.properties.add_property("birthdate", "1st January 2019") version = bot.get_version_string(self._client_context) self.assertIsNotNone(version) self.assertEqual("bot, App: v1.9.3 Grammar v37, initiated 1st January 2019", version) def test_bot_init_no_spellchecker_configuration(self): bot_config = BotConfiguration() bot_config._spelling = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.spell_checker) def test_bot_init_no_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.spell_checker) def test_bot_init_with_invalid_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.spell_checker) def test_bot_init_with_valid_spellchecker(self): bot_config = BotConfiguration() bot_config.spelling._classname = "programy.spelling.textblob_spelling.TextBlobSpellingChecker" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.spell_checker) def test_bot_init_no_splitter_configuration(self): bot_config = BotConfiguration() bot_config._splitter = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_splitter) def test_bot_init_no_splitterr(self): bot_config = BotConfiguration() bot_config.splitter._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_splitter) def test_bot_init_with_invalid_splitterr(self): bot_config = BotConfiguration() bot_config.splitter._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_splitter) def test_bot_init_with_valid_splitterr(self): bot_config = BotConfiguration() bot_config.splitter._classname = "programy.dialog.splitter.splitter.SentenceSplitter" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.sentence_splitter) def test_bot_init_no_joiner_configuration(self): bot_config = BotConfiguration() bot_config._joiner = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_joiner) def test_bot_init_no_joinerr(self): bot_config = BotConfiguration() bot_config.joiner._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_joiner) def test_bot_init_with_invalid_joinerr(self): bot_config = BotConfiguration() bot_config.joiner._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentence_joiner) def test_bot_init_with_valid_joinerr(self): bot_config = BotConfiguration() bot_config.joiner._classname = "programy.dialog.joiner.joiner.SentenceJoiner" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.sentence_joiner) def test_bot_init_no_translator_configuration(self): bot_config = BotConfiguration() bot_config._from_translator = None bot_config._to_translator = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.from_translator) self.assertIsNone(bot.to_translator) def test_bot_init_no_translatorr(self): bot_config = BotConfiguration() bot_config.from_translator._classname = None bot_config.to_translator._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.from_translator) self.assertIsNone(bot.to_translator) def test_bot_init_with_invalid_translatorr(self): bot_config = BotConfiguration() bot_config.from_translator._classname = "programy.spelling.checker.SpellingCheckerX" bot_config.to_translator._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.from_translator) self.assertIsNone(bot.to_translator) def test_bot_init_with_valid_translatorr(self): bot_config = BotConfiguration() bot_config.from_translator._classname = "programy.translate.textblob_translator.TextBlobTranslator" bot_config.to_translator._classname = "programy.translate.textblob_translator.TextBlobTranslator" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.from_translator) self.assertIsNotNone(bot.to_translator) def test_bot_init_no_sentiment_analyser_configuration(self): bot_config = BotConfiguration() bot_config._sentiment = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentiment_analyser) def test_bot_init_no_sentiment_analyserr(self): bot_config = BotConfiguration() bot_config.sentiment_analyser._classname = None client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentiment_analyser) def test_bot_init_with_invalid_sentiment_analyserr(self): bot_config = BotConfiguration() bot_config.sentiment_analyser._classname = "programy.spelling.checker.SpellingCheckerX" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNone(bot.sentiment_analyser) def test_bot_init_with_valid_sentiment_analyserr(self): bot_config = BotConfiguration() bot_config.sentiment_analyser._classname = "programy.sentiment.textblob_sentiment.TextBlobSentimentAnalyser" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.sentiment_analyser) def test_bot_init_default_brain(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.brain) def test_bot_init_supplied_brain(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertIsNotNone(bot.brain) def test_bot_defaultresponses(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertEqual(bot.default_response, "") self.assertEqual(bot.exit_response, "Bye!") def test_bot_with_config(self): configuration = ProgramyConfiguration(ConsoleConfiguration()) self.assertIsNotNone(configuration) self.assertIsNotNone(configuration.client_configuration.configurations[0]) self.assertIsNotNone(configuration.client_configuration.configurations[0].configurations[0]) configuration.client_configuration.configurations[0].prompt = ":" configuration.client_configuration.configurations[0].default_response = "No answer for that" configuration.client_configuration.configurations[0].exit_response = "See ya!" client = TestClient() bot = Bot(configuration.client_configuration.configurations[0], client) self.assertIsNotNone(bot) self.assertEqual(bot.default_response, "No answer for that") self.assertEqual(bot.exit_response, "See ya!") def test_bot_with_conversation(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertFalse(bot.has_conversation(self._client_context)) response = bot.ask_question(self._client_context, "hello") self.assertIsNotNone(response) self.assertTrue(bot.has_conversation(self._client_context)) response = bot.ask_question(self._client_context, "hello") self.assertIsNotNone(response) self.assertTrue(bot.has_conversation(self._client_context)) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = self._client_context.bot.brain response = bot.ask_question(client_context2, "hello") self.assertIsNotNone(response) self.assertTrue(bot.has_conversation(client_context2)) def test_bot_chat_loop(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) self.assertIsInstance(bot, Bot) bot.configuration._default_response = "Sorry, I don't have an answer for that right now" response = bot.ask_question(self._client_context, "hello") self.assertIsNotNone(response) self.assertEqual(response, "Sorry, I don't have an answer for that right now.") response = bot.ask_question(self._client_context, "hello again") self.assertIsNotNone(response) self.assertEqual(response, "Sorry, I don't have an answer for that right now.") response = bot.ask_question(self._client_context, "goodbye") self.assertIsNotNone(response) self.assertEqual(response, "Sorry, I don't have an answer for that right now.") conversation = bot.get_conversation(self._client_context) self.assertIsNotNone(conversation) self.assertEqual(conversation.previous_nth_question(2).sentence(0).text(), "hello") self.assertEqual(conversation.previous_nth_question(2).sentence(0).response, "Sorry, I don't have an answer for that right now") self.assertEqual(conversation.previous_nth_question(1).sentence(0).text(), "hello again") self.assertEqual(conversation.previous_nth_question(1).sentence(0).response, "Sorry, I don't have an answer for that right now") self.assertEqual(conversation.previous_nth_question(0).sentence(0).text(), "goodbye") self.assertEqual(conversation.previous_nth_question(0).sentence(0).response, "Sorry, I don't have an answer for that right now") def test_max_recusion(self): client = TestClient() bot = Bot(BotConfiguration(), client) self.assertIsNotNone(bot) bot.configuration._default_response = "Sorry, I don't have an answer for that right now" bot.configuration._max_question_recursion = 0 with self.assertRaises(Exception): bot.ask_question(self._client_context, "hello") def test_get_default_response_empty_string(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("", bot.get_default_response(self._client_context)) def test_get_default_response_default_response_only(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.default_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_default_response(self._client_context)) def test_get_default_response_default_response_srai_no_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.default_response_srai = "YDEFAULTRESPONSE" bot_config.default_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_default_response(self._client_context)) def test_get_default_response_default_response_srai_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.default_response_srai = "YDEFAULTRESPONSE" bot_config.default_response = "Default response!" client = TestClient() bot = MockBot(bot_config, client) self.assertIsNotNone(bot) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = MockBrain(bot, bot.configuration.configurations[0]) client_context2._brain._response = "Y DEFAULT RESPONSE" response = bot.get_default_response(client_context2) self.assertIsNotNone(response) self.assertEqual("Y DEFAULT RESPONSE", response) def test_get_default_response_no_srai(self): bot_config = BotConfiguration() bot_config._default_response_srai = None bot_config._default_response = "Test This" self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Test This", bot.get_default_response(self._client_context)) def test_get_initial_question_empty_string(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Hello", bot.get_initial_question(self._client_context)) def test_get_initial_question_initial_question_only(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.initial_question = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_initial_question(self._client_context)) def test_get_initial_question_initial_question_srai_no_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.initial_question_srai = "YDEFAULTRESPONSE" bot_config.initial_question = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_initial_question(self._client_context)) def test_get_initial_question_initial_question_srai_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = MockBot(bot_config, client) self.assertIsNotNone(bot) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = MockBrain(bot, bot.configuration.configurations[0]) client_context2._brain._response = "Y DEFAULT RESPONSE" self.assertEqual("Y DEFAULT RESPONSE", bot.get_initial_question(client_context2)) def test_get_initial_question_no_srai(self): bot_config = BotConfiguration() bot_config._initial_question = "Test This" bot_config._initial_question_srai = None self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Test This", bot.get_initial_question(self._client_context)) def test_get_exit_response_empty_string(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Bye!", bot.get_exit_response(self._client_context)) def test_get_exit_response_exit_response_only(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.exit_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_exit_response(self._client_context)) def test_get_exit_response_exit_response_srai_no_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.exit_response_srai = "YDEFAULTRESPONSE" bot_config.exit_response = "Default response!" client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Default response!", bot.get_exit_response(self._client_context)) def test_get_exit_response_exit_response_srai_match(self): bot_config = BotConfiguration() self.assertIsNotNone(bot_config) bot_config.exit_response_srai = "YDEFAULTRESPONSE" bot_config.exit_response = "Default response!" client = TestClient() bot = MockBot(bot_config, client) self.assertIsNotNone(bot) client_context2 = ClientContext(TestClient(), "testid2") client_context2._bot = bot client_context2._brain = MockBrain(bot, bot.configuration.configurations[0]) client_context2._brain._response = "Y DEFAULT RESPONSE" self.assertEqual("Y DEFAULT RESPONSE", bot.get_exit_response(client_context2)) def test_get_exit_response_no_srai(self): bot_config = BotConfiguration() bot_config._exit_response = "Test This" bot_config._exit_response_srai = None self.assertIsNotNone(bot_config) client = TestClient() bot = Bot(bot_config, client) self.assertIsNotNone(bot) self.assertEqual("Test This", bot.get_exit_response(self._client_context)) def test_log_answer(self): bot_config = BotConfiguration() client = TestClient() bot = Bot(bot_config, client) bot.log_answer(self._client_context, "Hello", "Test", None) response_logger = unittest.mock.Mock() bot.log_answer(self._client_context, "Hello", "Test", response_logger)

true

f71319f1474558e7e18729692f7649c4143dd552

842

py

Python

tsbot/exceptions.py

0x4aK/TSBot

21bee5e865d09f54907ab85092a632443d36c67d

[ "MIT" ]

null

tsbot/exceptions.py

0x4aK/TSBot

21bee5e865d09f54907ab85092a632443d36c67d

[ "MIT" ]

null

tsbot/exceptions.py

0x4aK/TSBot

21bee5e865d09f54907ab85092a632443d36c67d

[ "MIT" ]

null

class TSException(Exception): """Exception related to tsbot""" class TSResponseError(TSException): """Raised when response from server has error_id set to other than 0.""" def __init__(self, message: str, error_id: int) -> None: self.message = message self.error_id = error_id def __str__(self) -> str: return f"Error {self.error_id}: {self.message}" class TSCommandError(TSException): """ Command handlers can raise this exception to indicate that something went wrong while running the handler. """ class TSPermissionError(TSException): """ Command handlers can raise this exception to indicate that the user running this command doesn't have the proper permissions. """ class TSEventError(TSException): """Exception happend during event handling"""

25.515152

76

0.693587

class TSException(Exception): class TSResponseError(TSException): def __init__(self, message: str, error_id: int) -> None: self.message = message self.error_id = error_id def __str__(self) -> str: return f"Error {self.error_id}: {self.message}" class TSCommandError(TSException): class TSPermissionError(TSException): class TSEventError(TSException):

true

f7131aa149c22279c22f9be928455f06226e48b9

340

py

Python

python/ray/tune/sklearn.py

firebolt55439/ray

215300b070628c06f0106906fc6c03bd70ebf140

[ "Apache-2.0" ]

3

2020-12-03T17:48:45.000Z

2022-01-22T08:09:46.000Z

python/ray/tune/sklearn.py

firebolt55439/ray

215300b070628c06f0106906fc6c03bd70ebf140

[ "Apache-2.0" ]

84

2021-03-06T08:02:56.000Z

2022-03-05T08:07:19.000Z

python/ray/tune/sklearn.py

firebolt55439/ray

215300b070628c06f0106906fc6c03bd70ebf140

[ "Apache-2.0" ]

2

2020-05-22T15:36:27.000Z

2020-05-22T15:52:03.000Z

import logging logger = logging.getLogger(__name__) TuneSearchCV = None TuneGridSearchCV = None try: from tune_sklearn import TuneSearchCV, TuneGridSearchCV except ImportError: logger.info("tune_sklearn is not installed. Please run " "`pip install tune-sklearn`.") __all__ = ["TuneSearchCV", "TuneGridSearchCV"]

22.666667

60

0.735294

import logging logger = logging.getLogger(__name__) TuneSearchCV = None TuneGridSearchCV = None try: from tune_sklearn import TuneSearchCV, TuneGridSearchCV except ImportError: logger.info("tune_sklearn is not installed. Please run " "`pip install tune-sklearn`.") __all__ = ["TuneSearchCV", "TuneGridSearchCV"]

true

f7131bbbe72ac27eaf25a4616cb01b7766cbef5f

384

py

Python

code/pyorg/sub/__init__.py

anmartinezs/pyseg_system

5bb07c7901062452a34b73f376057cabc15a13c3

[ "Apache-2.0" ]

12

2020-01-08T01:33:02.000Z

2022-03-16T00:25:34.000Z

code/pyorg/sub/__init__.py

anmartinezs/pyseg_system

5bb07c7901062452a34b73f376057cabc15a13c3

[ "Apache-2.0" ]

8

2019-12-19T19:34:56.000Z

2022-03-10T10:11:28.000Z

code/pyorg/sub/__init__.py

anmartinezs/pyseg_system

5bb07c7901062452a34b73f376057cabc15a13c3

[ "Apache-2.0" ]

2

2022-03-30T13:12:22.000Z

2022-03-30T18:12:10.000Z

""" Set of specific utilities for combining PySeg with Subtomogram Averaging tools (PyTom) # Author: Antonio Martinez-Sanchez (Max Planck Institute for Biochemistry) # Date: 1.06.16 """ __author__ = 'Antonio Martinez-Sanchez' from .plist import TomoPeaks, SetTomoPeaks, Score, SingleTiltWedge, Particle, ParticleList, PK_COORDS from .star import Star from .fxml import XMLFilaments

32

101

0.791667

__author__ = 'Antonio Martinez-Sanchez' from .plist import TomoPeaks, SetTomoPeaks, Score, SingleTiltWedge, Particle, ParticleList, PK_COORDS from .star import Star from .fxml import XMLFilaments

true

f7131bdfb085b62573918111bf7a6d147b3dfd6c

41

py

Python

scripts/portal/mayong.py

G00dBye/YYMS

1de816fc842b6598d5b4b7896b6ab0ee8f7cdcfb

[ "MIT" ]

54

2019-04-16T23:24:48.000Z

2021-12-18T11:41:50.000Z

scripts/portal/mayong.py

G00dBye/YYMS

1de816fc842b6598d5b4b7896b6ab0ee8f7cdcfb

[ "MIT" ]

3

2019-05-19T15:19:41.000Z

2020-04-27T16:29:16.000Z

scripts/portal/mayong.py

G00dBye/YYMS

1de816fc842b6598d5b4b7896b6ab0ee8f7cdcfb

[ "MIT" ]

49

2020-11-25T23:29:16.000Z

2022-03-26T16:20:24.000Z

# Portal to Manon sm.warp(240020401, 3)

10.25

21

0.707317

sm.warp(240020401, 3)

true

f7131beae338b89bfacfc9f18fedc0be60b81ab9

1,810

py

Python

src/python/pants/backend/jvm/tasks/ivy_imports.py

arloherrine/pants

5f98f7734590eb21a2992a4c28415f838a2e6927

[ "Apache-2.0" ]

null

src/python/pants/backend/jvm/tasks/ivy_imports.py

arloherrine/pants

5f98f7734590eb21a2992a4c28415f838a2e6927

[ "Apache-2.0" ]

null

src/python/pants/backend/jvm/tasks/ivy_imports.py

arloherrine/pants

5f98f7734590eb21a2992a4c28415f838a2e6927

[ "Apache-2.0" ]

null

# coding=utf-8 # Copyright 2014 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import (absolute_import, division, generators, nested_scopes, print_function, unicode_literals, with_statement) from pants.backend.jvm.tasks.ivy_task_mixin import IvyTaskMixin from pants.backend.jvm.tasks.nailgun_task import NailgunTask class IvyImports(IvyTaskMixin, NailgunTask): """Resolves a jar of .proto files for each target in the context which has imports (ie, for each JavaProtobufLibrary target). """ _CONFIG_SECTION = 'ivy-imports' # TODO https://github.com/pantsbuild/pants/issues/604 product_types start @classmethod def product_types(cls): return ['ivy_imports'] # TODO https://github.com/pantsbuild/pants/issues/604 product_types finish @classmethod def prepare(cls, options, round_manager): super(IvyImports, cls).prepare(options, round_manager) round_manager.require_data('jvm_build_tools_classpath_callbacks') @property def config_section(self): return self._CONFIG_SECTION def _str_jar(self, jar): return 'jar' + str((jar.org, jar.name, jar.rev)) def execute(self): def nice_target_name(t): return t.address.spec resolve_for = self.context.targets(lambda t: t.has_label('has_imports')) if resolve_for: imports_map = self.context.products.get('ivy_imports') executor = self.create_java_executor() for target in resolve_for: jars = target.imports self.context.log.info('Mapping import jars for {target}: \n {jars}'.format( target=nice_target_name(target), jars='\n '.join(self._str_jar(s) for s in jars))) self.mapjars(imports_map, target, executor, jars=jars)

35.490196

98

0.722652

from __future__ import (absolute_import, division, generators, nested_scopes, print_function, unicode_literals, with_statement) from pants.backend.jvm.tasks.ivy_task_mixin import IvyTaskMixin from pants.backend.jvm.tasks.nailgun_task import NailgunTask class IvyImports(IvyTaskMixin, NailgunTask): _CONFIG_SECTION = 'ivy-imports' @classmethod def product_types(cls): return ['ivy_imports'] @classmethod def prepare(cls, options, round_manager): super(IvyImports, cls).prepare(options, round_manager) round_manager.require_data('jvm_build_tools_classpath_callbacks') @property def config_section(self): return self._CONFIG_SECTION def _str_jar(self, jar): return 'jar' + str((jar.org, jar.name, jar.rev)) def execute(self): def nice_target_name(t): return t.address.spec resolve_for = self.context.targets(lambda t: t.has_label('has_imports')) if resolve_for: imports_map = self.context.products.get('ivy_imports') executor = self.create_java_executor() for target in resolve_for: jars = target.imports self.context.log.info('Mapping import jars for {target}: \n {jars}'.format( target=nice_target_name(target), jars='\n '.join(self._str_jar(s) for s in jars))) self.mapjars(imports_map, target, executor, jars=jars)

true

f7131c248632a0b660c8fc2a29e3ea6a29d21a62

7,406

py

Python

nodep-keytool.py

imaginal/dozorro-keytool

863fc5c3d9cb2404ec0398e15bd041b2a5076126

[ "Apache-2.0" ]

null

nodep-keytool.py

imaginal/dozorro-keytool

863fc5c3d9cb2404ec0398e15bd041b2a5076126

[ "Apache-2.0" ]

null

nodep-keytool.py

imaginal/dozorro-keytool

863fc5c3d9cb2404ec0398e15bd041b2a5076126

[ "Apache-2.0" ]

null

#!/usr/bin/python # pure python keytool import os import sys import json import base64 import hashlib import datetime assert sys.version_info < (3,0), "Python 2.7 required" TZ = '+02:00' b = 256 q = 2**255 - 19 l = 2**252 + 27742317777372353535851937790883648493 def H(m): return hashlib.sha512(m).digest() def expmod(b,e,m): if e == 0: return 1 t = expmod(b,e/2,m)**2 % m if e & 1: t = (t*b) % m return t def inv(x): return expmod(x,q-2,q) d = -121665 * inv(121666) I = expmod(2,(q-1)/4,q) def xrecover(y): xx = (y*y-1) * inv(d*y*y+1) x = expmod(xx,(q+3)/8,q) if (x*x - xx) % q != 0: x = (x*I) % q if x % 2 != 0: x = q-x return x By = 4 * inv(5) Bx = xrecover(By) B = [Bx % q,By % q] def edwards(P,Q): x1 = P[0] y1 = P[1] x2 = Q[0] y2 = Q[1] x3 = (x1*y2+x2*y1) * inv(1+d*x1*x2*y1*y2) y3 = (y1*y2+x1*x2) * inv(1-d*x1*x2*y1*y2) return [x3 % q,y3 % q] def scalarmult(P,e): if e == 0: return [0,1] Q = scalarmult(P,e/2) Q = edwards(Q,Q) if e & 1: Q = edwards(Q,P) return Q def encodeint(y): bits = [(y >> i) & 1 for i in range(b)] return ''.join([chr(sum([bits[i * 8 + j] << j for j in range(8)])) for i in range(b/8)]) def encodepoint(P): x = P[0] y = P[1] bits = [(y >> i) & 1 for i in range(b - 1)] + [x & 1] return ''.join([chr(sum([bits[i * 8 + j] << j for j in range(8)])) for i in range(b/8)]) def bit(h,i): return (ord(h[i/8]) >> (i%8)) & 1 def publickey(sk): h = H(sk) a = 2**(b-2) + sum(2**i * bit(h,i) for i in range(3,b-2)) A = scalarmult(B,a) return encodepoint(A) def Hint(m): h = H(m) return sum(2**i * bit(h,i) for i in range(2*b)) def signature(m,sk,pk): h = H(sk) a = 2**(b-2) + sum(2**i * bit(h,i) for i in range(3,b-2)) r = Hint(''.join([h[i] for i in range(b/8,b/4)]) + m) R = scalarmult(B,r) S = (r + Hint(encodepoint(R) + pk + m) * a) % l return encodepoint(R) + encodeint(S) def isoncurve(P): x = P[0] y = P[1] return (-x*x + y*y - 1 - d*x*x*y*y) % q == 0 def decodeint(s): return sum(2**i * bit(s,i) for i in range(0,b)) def decodepoint(s): y = sum(2**i * bit(s,i) for i in range(0,b-1)) x = xrecover(y) if x & 1 != bit(s,b-1): x = q-x P = [x,y] if not isoncurve(P): raise Exception("decoding point that is not on curve") return P def checkvalid(s,m,pk): if len(s) != b/4: raise Exception("signature length is wrong") if len(pk) != b/8: raise Exception("public-key length is wrong") R = decodepoint(s[0:b/8]) A = decodepoint(pk) S = decodeint(s[b/8:b/4]) h = Hint(encodepoint(R) + pk + m) if scalarmult(B,S) != edwards(R,scalarmult(A,h)): raise Exception("signature does not pass verification") def generate(seckey='keyseed.dat', entropy=os.urandom): if os.path.exists(seckey): print('Error: file already exists {}'.format(seckey)) return 1 sk = entropy(32) with open(seckey, 'wb') as fp: fp.write(sk) os.chmod(seckey, 0o600) print('Private signing key saved to {}'.format(seckey)) def hash_id(datas): h1 = hashlib.sha256(datas).digest() h2 = hashlib.sha256(h1).hexdigest() return h2[:32] def dump_binstr(data): datas = json.dumps(data, skipkeys=False, ensure_ascii=False, sort_keys=True, separators=(',',':')) return datas.encode('utf-8') def data_sign(data, sk, pk): datas = dump_binstr(data['envelope']) data['id'] = hash_id(datas) sign = signature(datas, sk, pk) data['sign'] = base64.b64encode(sign).rstrip('=') def data_verify(data, vk): sign = base64.b64decode(data['sign']) data_bin = dump_binstr(data['envelope']) data_hid = hash_id(data_bin) assert data_hid == data['id'], 'Bad hash ID' checkvalid(sign, data_bin, vk) def dump_pretty(data): datas = json.dumps(data, indent=2, ensure_ascii=False, sort_keys=True) return datas.encode('utf-8') def export_pubkey(seckey='keyseed.dat', pubkey='pubkey.json', owner_name='root'): sk = open(seckey, 'rb').read() vk = publickey(sk) vk_s = vk.encode('hex') dt_now = datetime.datetime.now() dt_exp = dt_now + datetime.timedelta(days=365) data = { 'envelope': { 'date': dt_now.isoformat()+TZ, 'model': 'admin/pubkey', 'owner': owner_name, 'payload': { 'algorithm': 'Ed25519', 'owner': owner_name, 'publicKey': vk_s, 'validSince': dt_now.isoformat()+TZ, 'validTill': dt_exp.isoformat()+TZ } } } data_sign(data, sk, vk) datas = dump_pretty(data) with open(pubkey, 'wb') as fp: fp.write(datas.encode('utf-8')) print('Public verifying key saved to {}'.format(pubkey)) def verify_file(pubkey='pubkey.json', datafile=None): if len(sys.argv) > 2: datafile = sys.argv[2] if datafile and datafile != pubkey: print('Load public key data from {}'.format(pubkey)) print('Verify any data json from {}'.format(datafile)) else: print('Verify public key data from {}'.format(pubkey)) with open(pubkey) as fp: data = json.loads(fp.read()) vkey_hex = data['envelope']['payload']['publicKey'] vk = vkey_hex.decode('hex') if datafile and datafile != pubkey: with open(datafile) as fp: data = json.loads(fp.read()) try: data_verify(data, vk) print("Result OK") except Exception as e: print("Can't verify: {}".format(e)) return 1 return 0 def sign_file(seckey='keyseed.dat', pubkey='pubkey.json', datafile='data.json'): sk = open(seckey, 'rb').read() vk = publickey(sk) vk_s = vk.encode('hex') with open(pubkey) as fp: pubkey_data = json.loads(fp.read()) pubkey_payload = pubkey_data['envelope']['payload'] vkey_hex = pubkey_payload['publicKey'].encode() assert vk_s == vkey_hex, 'Keys mismatch' print('Load data json from {}'.format(datafile)) with open(datafile) as fp: data = json.loads(fp.read()) if '--set-date' in sys.argv: dt_now = datetime.datetime.now() data['envelope']['date'] = dt_now.isoformat()+TZ data['envelope']['owner'] = pubkey_payload['owner'] data_sign(data, sk, vk) if '--compact' in sys.argv: datas = dump_binstr(data) else: datas = dump_pretty(data) print('Save signed json to {}'.format(datafile)) with open(datafile, 'w') as fp: fp.write(datas) def usage(): print('Usage: admin-keytool.py command [args]\n') print(' admin-keytool.py generate\n') print(' admin-keytool.py export owner_name\n') print(' admin-keytool.py verify [pubkey.json]\n') print(' admin-keytool.py sign anydata.json\n') return 2 def main(): if len(sys.argv) < 2: return usage() cmd = sys.argv[1] if cmd == 'generate': return generate() elif cmd == 'export' and len(sys.argv) > 2: return export_pubkey(owner_name=sys.argv[2]) elif cmd == 'verify': return verify_file() elif cmd == 'sign' and len(sys.argv) > 2: return sign_file(datafile=sys.argv[2]) else: return usage() if __name__ == '__main__': sys.exit(main())

26.355872

92

0.569133

import os import sys import json import base64 import hashlib import datetime assert sys.version_info < (3,0), "Python 2.7 required" TZ = '+02:00' b = 256 q = 2**255 - 19 l = 2**252 + 27742317777372353535851937790883648493 def H(m): return hashlib.sha512(m).digest() def expmod(b,e,m): if e == 0: return 1 t = expmod(b,e/2,m)**2 % m if e & 1: t = (t*b) % m return t def inv(x): return expmod(x,q-2,q) d = -121665 * inv(121666) I = expmod(2,(q-1)/4,q) def xrecover(y): xx = (y*y-1) * inv(d*y*y+1) x = expmod(xx,(q+3)/8,q) if (x*x - xx) % q != 0: x = (x*I) % q if x % 2 != 0: x = q-x return x By = 4 * inv(5) Bx = xrecover(By) B = [Bx % q,By % q] def edwards(P,Q): x1 = P[0] y1 = P[1] x2 = Q[0] y2 = Q[1] x3 = (x1*y2+x2*y1) * inv(1+d*x1*x2*y1*y2) y3 = (y1*y2+x1*x2) * inv(1-d*x1*x2*y1*y2) return [x3 % q,y3 % q] def scalarmult(P,e): if e == 0: return [0,1] Q = scalarmult(P,e/2) Q = edwards(Q,Q) if e & 1: Q = edwards(Q,P) return Q def encodeint(y): bits = [(y >> i) & 1 for i in range(b)] return ''.join([chr(sum([bits[i * 8 + j] << j for j in range(8)])) for i in range(b/8)]) def encodepoint(P): x = P[0] y = P[1] bits = [(y >> i) & 1 for i in range(b - 1)] + [x & 1] return ''.join([chr(sum([bits[i * 8 + j] << j for j in range(8)])) for i in range(b/8)]) def bit(h,i): return (ord(h[i/8]) >> (i%8)) & 1 def publickey(sk): h = H(sk) a = 2**(b-2) + sum(2**i * bit(h,i) for i in range(3,b-2)) A = scalarmult(B,a) return encodepoint(A) def Hint(m): h = H(m) return sum(2**i * bit(h,i) for i in range(2*b)) def signature(m,sk,pk): h = H(sk) a = 2**(b-2) + sum(2**i * bit(h,i) for i in range(3,b-2)) r = Hint(''.join([h[i] for i in range(b/8,b/4)]) + m) R = scalarmult(B,r) S = (r + Hint(encodepoint(R) + pk + m) * a) % l return encodepoint(R) + encodeint(S) def isoncurve(P): x = P[0] y = P[1] return (-x*x + y*y - 1 - d*x*x*y*y) % q == 0 def decodeint(s): return sum(2**i * bit(s,i) for i in range(0,b)) def decodepoint(s): y = sum(2**i * bit(s,i) for i in range(0,b-1)) x = xrecover(y) if x & 1 != bit(s,b-1): x = q-x P = [x,y] if not isoncurve(P): raise Exception("decoding point that is not on curve") return P def checkvalid(s,m,pk): if len(s) != b/4: raise Exception("signature length is wrong") if len(pk) != b/8: raise Exception("public-key length is wrong") R = decodepoint(s[0:b/8]) A = decodepoint(pk) S = decodeint(s[b/8:b/4]) h = Hint(encodepoint(R) + pk + m) if scalarmult(B,S) != edwards(R,scalarmult(A,h)): raise Exception("signature does not pass verification") def generate(seckey='keyseed.dat', entropy=os.urandom): if os.path.exists(seckey): print('Error: file already exists {}'.format(seckey)) return 1 sk = entropy(32) with open(seckey, 'wb') as fp: fp.write(sk) os.chmod(seckey, 0o600) print('Private signing key saved to {}'.format(seckey)) def hash_id(datas): h1 = hashlib.sha256(datas).digest() h2 = hashlib.sha256(h1).hexdigest() return h2[:32] def dump_binstr(data): datas = json.dumps(data, skipkeys=False, ensure_ascii=False, sort_keys=True, separators=(',',':')) return datas.encode('utf-8') def data_sign(data, sk, pk): datas = dump_binstr(data['envelope']) data['id'] = hash_id(datas) sign = signature(datas, sk, pk) data['sign'] = base64.b64encode(sign).rstrip('=') def data_verify(data, vk): sign = base64.b64decode(data['sign']) data_bin = dump_binstr(data['envelope']) data_hid = hash_id(data_bin) assert data_hid == data['id'], 'Bad hash ID' checkvalid(sign, data_bin, vk) def dump_pretty(data): datas = json.dumps(data, indent=2, ensure_ascii=False, sort_keys=True) return datas.encode('utf-8') def export_pubkey(seckey='keyseed.dat', pubkey='pubkey.json', owner_name='root'): sk = open(seckey, 'rb').read() vk = publickey(sk) vk_s = vk.encode('hex') dt_now = datetime.datetime.now() dt_exp = dt_now + datetime.timedelta(days=365) data = { 'envelope': { 'date': dt_now.isoformat()+TZ, 'model': 'admin/pubkey', 'owner': owner_name, 'payload': { 'algorithm': 'Ed25519', 'owner': owner_name, 'publicKey': vk_s, 'validSince': dt_now.isoformat()+TZ, 'validTill': dt_exp.isoformat()+TZ } } } data_sign(data, sk, vk) datas = dump_pretty(data) with open(pubkey, 'wb') as fp: fp.write(datas.encode('utf-8')) print('Public verifying key saved to {}'.format(pubkey)) def verify_file(pubkey='pubkey.json', datafile=None): if len(sys.argv) > 2: datafile = sys.argv[2] if datafile and datafile != pubkey: print('Load public key data from {}'.format(pubkey)) print('Verify any data json from {}'.format(datafile)) else: print('Verify public key data from {}'.format(pubkey)) with open(pubkey) as fp: data = json.loads(fp.read()) vkey_hex = data['envelope']['payload']['publicKey'] vk = vkey_hex.decode('hex') if datafile and datafile != pubkey: with open(datafile) as fp: data = json.loads(fp.read()) try: data_verify(data, vk) print("Result OK") except Exception as e: print("Can't verify: {}".format(e)) return 1 return 0 def sign_file(seckey='keyseed.dat', pubkey='pubkey.json', datafile='data.json'): sk = open(seckey, 'rb').read() vk = publickey(sk) vk_s = vk.encode('hex') with open(pubkey) as fp: pubkey_data = json.loads(fp.read()) pubkey_payload = pubkey_data['envelope']['payload'] vkey_hex = pubkey_payload['publicKey'].encode() assert vk_s == vkey_hex, 'Keys mismatch' print('Load data json from {}'.format(datafile)) with open(datafile) as fp: data = json.loads(fp.read()) if '--set-date' in sys.argv: dt_now = datetime.datetime.now() data['envelope']['date'] = dt_now.isoformat()+TZ data['envelope']['owner'] = pubkey_payload['owner'] data_sign(data, sk, vk) if '--compact' in sys.argv: datas = dump_binstr(data) else: datas = dump_pretty(data) print('Save signed json to {}'.format(datafile)) with open(datafile, 'w') as fp: fp.write(datas) def usage(): print('Usage: admin-keytool.py command [args]\n') print(' admin-keytool.py generate\n') print(' admin-keytool.py export owner_name\n') print(' admin-keytool.py verify [pubkey.json]\n') print(' admin-keytool.py sign anydata.json\n') return 2 def main(): if len(sys.argv) < 2: return usage() cmd = sys.argv[1] if cmd == 'generate': return generate() elif cmd == 'export' and len(sys.argv) > 2: return export_pubkey(owner_name=sys.argv[2]) elif cmd == 'verify': return verify_file() elif cmd == 'sign' and len(sys.argv) > 2: return sign_file(datafile=sys.argv[2]) else: return usage() if __name__ == '__main__': sys.exit(main())

true

f7131c47fe402b905f53f41cdbcbe559cb420314

756

py

Python

src/scripts/eval/surface_distance/__init__.py

elitap/classimbalance

ae807ec533da5eef18f4180b29383399bc57696a

[ "Apache-2.0" ]

1

2022-03-13T01:48:54.000Z

src/scripts/eval/surface_distance/__init__.py

elitap/classimbalance

ae807ec533da5eef18f4180b29383399bc57696a

[ "Apache-2.0" ]

null

src/scripts/eval/surface_distance/__init__.py

elitap/classimbalance

ae807ec533da5eef18f4180b29383399bc57696a

[ "Apache-2.0" ]

null

# Copyright 2018 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. """Surface distance module: https://github.com/deepmind/surface-distance .""" # from .metrics import * # pylint: disable=wildcard-import __version__ = "0.1"

42

77

0.753968

true

f7131c78aa391ffbfd3f950556669abc142582fd

2,062

py

Python

Respaldo/package_robot/src/nodo_publisher.py

Tachuelin/RMA-Dedutel

796add66dc20efe8205055a648c01a5a5de194ad

[ "MIT" ]

1

2022-03-30T22:29:33.000Z

Respaldo/package_robot/src/nodo_publisher.py

Tachuelin/RMA-Dedutel

796add66dc20efe8205055a648c01a5a5de194ad

[ "MIT" ]

null

Respaldo/package_robot/src/nodo_publisher.py

Tachuelin/RMA-Dedutel

796add66dc20efe8205055a648c01a5a5de194ad

[ "MIT" ]

null

#!/usr/bin/env python3 # encoding: utf-8 #Linea 1 - “Shebang”,le indicamos a la máquina con qué programa lo vamos a ejecutar. #Linea 2 - Python 3 - asume que solo se utiliza ASCII en el código fuente #para usar utf-8 hay que indicarlo al principio de nuestro script encoding: utf-8 import rospy #Importamos ropsy (interface de python-ROS) from std_msgs.msg import String #Importamos tipo de mensaje String def nodo(): #Definimos una función nodo rospy.init_node('nodo_publisher') #Inicializamos nuestro nodo y le asignamos un nombre = nodo_publisher pub = rospy.Publisher('example', String, queue_size=10) #Definimos nuestro topico con nombre example y tipo de mensaje String #con un límite de 10 mensajes en cola rate = rospy.Rate(10) #Crea un objeto Rate a 10hz (loop 10 times per second) while not rospy.is_shutdown(): #Bucle While - hasta pulsar Ctrl-C mensaje = "Nodo Publisher" #Declaramos una variable mensaje y asignamos una cadena de caracteres rospy.loginfo(mensaje) #Imprime en pantalla mensajes logs de tipo Info pub.publish(mensaje) #Publicamos un mensaje de tipo String en nuestro tópico example rate.sleep() if __name__ == '__main__': #Llamamos a la función principal main try: nodo() # Lamamos a la función nodo except rospy.ROSInterruptException: # Check si hay una excepción Ctrl-C para terminar la ejecución del nodo pass

60.647059

132

0.509699

import rospy from std_msgs.msg import String def nodo(): rospy.init_node('nodo_publisher') pub = rospy.Publisher('example', String, queue_size=10) rate = rospy.Rate(10) while not rospy.is_shutdown(): mensaje = "Nodo Publisher" rospy.loginfo(mensaje) pub.publish(mensaje) rate.sleep() if __name__ == '__main__': try: nodo() except rospy.ROSInterruptException: pass

true

f7131d94547f05290822d35deec65ccf383bab60

10,216

py

Python

scripts/track_length_analysis_test.py

vik748/OpenSfM

bd949246e3e0d6d3a707a08224038034d27e3ee8

[ "BSD-2-Clause" ]

null

scripts/track_length_analysis_test.py

vik748/OpenSfM

bd949246e3e0d6d3a707a08224038034d27e3ee8

[ "BSD-2-Clause" ]

null

scripts/track_length_analysis_test.py

vik748/OpenSfM

bd949246e3e0d6d3a707a08224038034d27e3ee8

[ "BSD-2-Clause" ]

null

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Mon Apr 19 08:11:51 2021 @author: vik748 """ import json import numpy as np import matplotlib.pyplot as plt import sys,os import pandas as pd def tracks_histogram(recon_file, tracks_file, ax, model_num=0, bins=np.linspace(2,15,14)): ''' How the tracks.csv file is written template <class S> void WriteToStreamCurrentVersion(S& ostream, const TracksManager& manager) { ostream << manager.TRACKS_HEADER << "_v" << manager.TRACKS_VERSION << std::endl; const auto shotsIDs = manager.GetShotIds(); for (const auto& shotID : shotsIDs) { const auto observations = manager.GetShotObservations(shotID); for (const auto& observation : observations) { ostream << shotID << "\t" << observation.first << "\t" << observation.second.id << "\t" << observation.second.point(0) << "\t" << observation.second.point(1) << "\t" << observation.second.scale << "\t" << observation.second.color(0) << "\t" << observation.second.color(1) << "\t" << observation.second.color(2) << std::endl; } } } ''' with open(recon_file) as f: data = json.load(f) if model_num == -1: points_dict = {} for d in data: points_dict.update(d['points']) else: points_dict = data[model_num]['points'] model_0_point_ids_int = [int(k) for k in points_dict.keys()] tracks_df = pd.read_csv(tracks_file, sep='\t', skiprows=1, names=['image', 'track_id', 'feature_id', 'x', 'y', 'scale', 'r', 'g', 'b']) track_id_counts = tracks_df.track_id.value_counts() model_0_track_id_counts = track_id_counts[model_0_point_ids_int] ax.hist(model_0_track_id_counts, bins=bins) return model_0_track_id_counts ######################################## # Skerki_mud SIFT - RAW vs CLAHE - Model 0 ######################################## recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_SIFT_tracks.csv' fig1, ax = plt.subplots(nrows=2, sharex=True, sharey=True) fig1.suptitle('Skerki Mud SIFT') tracks_histogram(recon_file, tracks_file, ax[0], bins=np.linspace(2,15,14)) ax[0].set_xlim([2, None]) ax[0].set_yscale('log') ax[0].set_ylim([None, 10000]) ax[0].set_title('RAW') ax[0].set_xlabel('Feature Track Length') ax[0].set_ylabel('Fequency') ax[0].xaxis.set_major_locator(plt.MultipleLocator(1)) recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_CLAHE_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_CLAHE_SIFT_tracks.csv' tracks_histogram(recon_file, tracks_file, ax[1], bins=np.linspace(2,15,14)) ax[1].set_title('CLAHE') ax[1].set_xlabel('Feature Track Length') ax[1].set_ylabel('Fequency') ######################################## # Skerki_mud RAW - SIFT vs Zernike ######################################## recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_SIFT_tracks.csv' fig2, ax = plt.subplots(nrows=2, sharex=True, sharey=True) fig2.suptitle('Skerki Mud RAW') tracks_histogram(recon_file, tracks_file, ax[0], bins=np.linspace(2,15,14)) ax[0].set_xlim([2, None]) ax[0].set_yscale('log') ax[0].set_ylim([None, 10000]) ax[0].set_title('SIFT') ax[0].set_xlabel('Feature Track Length') ax[0].set_ylabel('Fequency') ax[0].xaxis.set_major_locator(plt.MultipleLocator(1)) recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_ZERNIKE_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_ZERNIKE_tracks.csv' tracks_histogram(recon_file, tracks_file, ax[1], model_num=1, bins=np.linspace(2,15,14)) ax[1].set_title('ZERNIKE') ax[1].set_xlabel('Feature Track Length') ax[1].set_ylabel('Fequency') ######################################## # Skerki_mud Zernike - RAW vs CLAHE ######################################## recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_ZERNIKE_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_ZERNIKE_tracks.csv' fig3, ax = plt.subplots(nrows=2, sharex=True, sharey=True) fig3.suptitle('Skerki Mud ZERNIKE') tracks_histogram(recon_file, tracks_file, ax[0], model_num=1, bins=np.linspace(2,15,14)) ax[0].set_xlim([2, None]) ax[0].set_yscale('log') ax[0].set_ylim([None, 10000]) ax[0].set_title('RAW') ax[0].set_xlabel('Feature Track Length') ax[0].set_ylabel('Fequency') ax[0].xaxis.set_major_locator(plt.MultipleLocator(1)) recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_CLAHE_ZERNIKE_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_CLAHE_ZERNIKE_tracks.csv' tracks_histogram(recon_file, tracks_file, ax[1], bins=np.linspace(2,15,14)) ax[1].set_title('CLAHE') ax[1].set_xlabel('Feature Track Length') ax[1].set_ylabel('Fequency') ######################################## # Stingray - SIFT vs Zernike ######################################## recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_SIFT_tracks.csv' fig4, ax = plt.subplots(nrows=2, sharex=True, sharey=True) fig4.suptitle('Stingray RAW') tracks_histogram(recon_file, tracks_file, ax[0], bins=np.linspace(2,15,14)) ax[0].set_xlim([2, None]) ax[0].set_yscale('log') ax[0].set_ylim([None, 10000]) ax[0].set_title('SIFT') ax[0].set_xlabel('Feature Track Length') ax[0].set_ylabel('Fequency') ax[0].xaxis.set_major_locator(plt.MultipleLocator(1)) recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_ZERNIKE_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_ZERNIKE_tracks.csv' tracks_histogram(recon_file, tracks_file, ax[1], bins=np.linspace(2,15,14)) ax[1].set_title('ZERNIKE') ax[1].set_xlabel('Feature Track Length') ax[1].set_ylabel('Fequency') ######################################## # Skerki_mud SIFT - RAW vs CLAHE - Combined ######################################## recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_RAW_SIFT_tracks.csv' fig5, ax = plt.subplots(nrows=2, sharex=True, sharey=True) fig5.suptitle('Skerki Mud SIFT - Combined') tracks_histogram(recon_file, tracks_file, ax[0], model_num=-1, bins=np.linspace(2,15,14)) ax[0].set_xlim([2, None]) ax[0].set_yscale('log') ax[0].set_ylim([None, 10000]) ax[0].set_title('RAW') ax[0].set_xlabel('Feature Track Length') ax[0].set_ylabel('Fequency') ax[0].xaxis.set_major_locator(plt.MultipleLocator(1)) recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_CLAHE_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Skerki_mud/Skerki_mud_CLAHE_SIFT_tracks.csv' tracks_histogram(recon_file, tracks_file, ax[1], bins=np.linspace(2,15,14)) ax[1].set_title('CLAHE') ax[1].set_xlabel('Feature Track Length') ax[1].set_ylabel('Fequency') ######################################## # Stingray SIFT - RAW vs CLAHE ######################################## recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_SIFT_tracks.csv' fig6, ax = plt.subplots(nrows=2, sharex=True, sharey=True) fig6.suptitle('Stingray SIFT') tracks_histogram(recon_file, tracks_file, ax[0], bins=np.linspace(2,15,14)) ax[0].set_xlim([2, None]) ax[0].set_yscale('log') ax[0].set_ylim([None, 10000]) ax[0].set_title('RAW') ax[0].set_xlabel('Feature Track Length') ax[0].set_ylabel('Fequency') ax[0].xaxis.set_major_locator(plt.MultipleLocator(1)) recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_CLAHE_SIFT_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_CLAHE_SIFT_tracks.csv' tracks_histogram(recon_file, tracks_file, ax[1], bins=np.linspace(2,15,14)) ax[1].set_title('CLAHE') ax[1].set_xlabel('Feature Track Length') ax[1].set_ylabel('Fequency') ######################################## # Stingray Zernike - RAW vs CLAHE ######################################## recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_ZERNIKE_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_ZERNIKE_tracks.csv' fig7, ax = plt.subplots(nrows=2, sharex=True, sharey=True) fig7.suptitle('Stingray ZERNIKE') counts0 = tracks_histogram(recon_file, tracks_file, ax[0], bins=np.linspace(2,15,14)) ax[0].set_xlim([2, None]) ax[0].set_yscale('log') ax[0].set_ylim([None, 10000]) ax[0].set_title('RAW') ax[0].set_xlabel('Feature Track Length') ax[0].set_ylabel('Fequency') ax[0].xaxis.set_major_locator(plt.MultipleLocator(1)) recon_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_CLAHE_ZERNIKE_reconstruction.json' tracks_file = '/home/vik748/data/OpenSfM_data/track_length_test_data/Stingray/Stingray_CLAHE_ZERNIKE_tracks.csv' counts1 = tracks_histogram(recon_file, tracks_file, ax[1], bins=np.linspace(2,15,14)) ax[1].set_title('CLAHE') ax[1].set_xlabel('Feature Track Length') ax[1].set_ylabel('Fequency') plt.hist([counts1, counts2], np.linspace(2,15,14), label=['RAW', 'CLAHE']) plt.legend(loc='upper right') plt.show()

38.844106

124

0.707224

import json import numpy as np import matplotlib.pyplot as plt import sys,os import pandas as pd def tracks_histogram(recon_file, tracks_file, ax, model_num=0, bins=np.linspace(2,15,14)): with open(recon_file) as f: data = json.load(f) if model_num == -1: points_dict = {} for d in data: points_dict.update(d['points']) else: points_dict = data[model_num]['points'] model_0_point_ids_int = [int(k) for k in points_dict.keys()] tracks_df = pd.read_csv(tracks_file, sep='\t', skiprows=1, names=['image', 'track_id', 'feature_id', 'x', 'y', 'scale', 'r', 'g', 'b']) track_id_counts = tracks_df.track_id.value_counts() model_0_track_id_counts = track_id_counts[model_0_point_ids_int] ax.hist(model_0_track_id_counts, bins=bins) return model_0_track_id_counts

true

f7131e8980207330c8d8d3873e5caa241cdfc2f1

770

py

Python

ermaket/api/generation/templates/system_role.tmpl.py

SqrtMinusOne/ERMaket_Experiment

c4a7b61651edd15a619d9b690e2aaeaab4de282d

[ "Apache-2.0" ]

null

ermaket/api/generation/templates/system_role.tmpl.py

SqrtMinusOne/ERMaket_Experiment

c4a7b61651edd15a619d9b690e2aaeaab4de282d

[ "Apache-2.0" ]

null

ermaket/api/generation/templates/system_role.tmpl.py

SqrtMinusOne/ERMaket_Experiment

c4a7b61651edd15a619d9b690e2aaeaab4de282d

[ "Apache-2.0" ]

null

import sqlalchemy as sa from .base import Base __all__ = ['Role'] class Role(Base): __tablename__ = 'role' __table_args__ = {'schema': 'system'} name = sa.Column(sa.String(256), primary_key=True) is_default = sa.Column(sa.Boolean(), default=False) can_reset_password = sa.Column(sa.Boolean(), default=False) has_sql_access = sa.Column(sa.Boolean(), default=False) can_register_all = sa.Column(sa.Boolean(), default=False) can_register = sa.Column(sa.ARRAY(sa.String), nullable=True) linked_entity_schema = sa.Column(sa.String(256), nullable=True) linked_entity_name = sa.Column(sa.String(256), nullable=True) users = sa.orm.relationship( 'User', secondary='system.user_has_roles', back_populates='roles' )

29.615385

73

0.698701

import sqlalchemy as sa from .base import Base __all__ = ['Role'] class Role(Base): __tablename__ = 'role' __table_args__ = {'schema': 'system'} name = sa.Column(sa.String(256), primary_key=True) is_default = sa.Column(sa.Boolean(), default=False) can_reset_password = sa.Column(sa.Boolean(), default=False) has_sql_access = sa.Column(sa.Boolean(), default=False) can_register_all = sa.Column(sa.Boolean(), default=False) can_register = sa.Column(sa.ARRAY(sa.String), nullable=True) linked_entity_schema = sa.Column(sa.String(256), nullable=True) linked_entity_name = sa.Column(sa.String(256), nullable=True) users = sa.orm.relationship( 'User', secondary='system.user_has_roles', back_populates='roles' )

true

f7131eaf697fba50c2554c9390890aa774c78363

1,468

py

Python

VrDemoServer/server.py

svdh2/SerceerVrDemo

7ab3d5cfd5fc7d0bf51a281f51688b6ad5d273cb

[ "Apache-2.0" ]

null

VrDemoServer/server.py

svdh2/SerceerVrDemo

7ab3d5cfd5fc7d0bf51a281f51688b6ad5d273cb

[ "Apache-2.0" ]

null

VrDemoServer/server.py

svdh2/SerceerVrDemo

7ab3d5cfd5fc7d0bf51a281f51688b6ad5d273cb

[ "Apache-2.0" ]

null

from flask import Flask, send_from_directory import os import connexion from connexion.resolver import RestyResolver from flask_socketio import SocketIO, send, emit # Constants STATIC_FILES_DIR = 'static' # The application server app = connexion.FlaskApp(__name__, specification_dir='swagger/', resolver=RestyResolver('VrDemoServer.api')) flask_app = app.app # We define the websocket feature socketio = SocketIO(flask_app) @socketio.on('message') def handle_message(message): print('received message: ' + message) emit('my response', "res"+message) # We add the OpenApi definitions app.add_api('demo2.yaml') # we define that all static content will be served from the STATIC_FILES_DIR subdirectory static_files_dir_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), STATIC_FILES_DIR) app.static_folder = STATIC_FILES_DIR app.add_url_rule( app.app.static_url_path + "/<path:filename>", endpoint="static", view_func=app.app.send_static_file, ) # we redirect the root index.thml to the app_index.html @app.route('/', methods=['GET']) def serve_index(): return send_from_directory(static_files_dir_path, 'app_index.html') # function to launch the server def run_server(ip, port=8080, debug=False): # print('starting rest api') # app.run(host=ip, port=port, debug=debug) print('starting websocket') socketio.run(flask_app, host=ip, port=port, debug=debug)

28.784314

108

0.73297

from flask import Flask, send_from_directory import os import connexion from connexion.resolver import RestyResolver from flask_socketio import SocketIO, send, emit STATIC_FILES_DIR = 'static' app = connexion.FlaskApp(__name__, specification_dir='swagger/', resolver=RestyResolver('VrDemoServer.api')) flask_app = app.app socketio = SocketIO(flask_app) @socketio.on('message') def handle_message(message): print('received message: ' + message) emit('my response', "res"+message) app.add_api('demo2.yaml') static_files_dir_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), STATIC_FILES_DIR) app.static_folder = STATIC_FILES_DIR app.add_url_rule( app.app.static_url_path + "/<path:filename>", endpoint="static", view_func=app.app.send_static_file, ) @app.route('/', methods=['GET']) def serve_index(): return send_from_directory(static_files_dir_path, 'app_index.html') def run_server(ip, port=8080, debug=False): print('starting websocket') socketio.run(flask_app, host=ip, port=port, debug=debug)

true

f7131ec54add247122406a15a979f3b26c8c105a

642

py

Python

setup.py

adamzerella/is-natural-number

584bc21a5d5d01ace31b9d94b44d32409dec233f

[ "MIT" ]

null

setup.py

adamzerella/is-natural-number

584bc21a5d5d01ace31b9d94b44d32409dec233f

[ "MIT" ]

2

2019-05-03T14:55:22.000Z

2019-05-03T15:02:59.000Z

setup.py

adamzerella/is-natural-number

584bc21a5d5d01ace31b9d94b44d32409dec233f

[ "MIT" ]

null

import setuptools with open("README.md", "r") as fh: long_description = fh.read() setuptools.setup( name="is-natural-number", version="1.0.0", author="Adam Zerella", author_email="hello@adamzerella.com", description="Check if a value is a natural number", long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/adamzerella/is-natural-number", packages=setuptools.find_packages(), classifiers=[ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], )

30.571429

59

0.67134

import setuptools with open("README.md", "r") as fh: long_description = fh.read() setuptools.setup( name="is-natural-number", version="1.0.0", author="Adam Zerella", author_email="hello@adamzerella.com", description="Check if a value is a natural number", long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/adamzerella/is-natural-number", packages=setuptools.find_packages(), classifiers=[ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], )

true

f7131f326b5d65183687dcd78a7d4976fa2b1ac7

37,927

py

Python

Python/pywarpx/fields.py

prkkumar/WarpX

a83c9c03ecc9850cd724efc14075eb95ff8a6138

[ "BSD-3-Clause-LBNL" ]

1

2021-07-12T14:17:45.000Z

Python/pywarpx/fields.py

prkkumar/WarpX

a83c9c03ecc9850cd724efc14075eb95ff8a6138

[ "BSD-3-Clause-LBNL" ]

null

Python/pywarpx/fields.py

prkkumar/WarpX

a83c9c03ecc9850cd724efc14075eb95ff8a6138

[ "BSD-3-Clause-LBNL" ]

1

2021-07-12T14:18:44.000Z

# Copyright 2017-2019 David Grote # # This file is part of WarpX. # # License: BSD-3-Clause-LBNL """Provides wrappers around field and current density on multiFABs Available routines: ExWrapper, EyWrapper, EzWrapper BxWrapper, ByWrapper, BzWrapper JxWrapper, JyWrapper, JzWrapper """ import numpy as np try: from mpi4py import MPI as mpi comm_world = mpi.COMM_WORLD npes = comm_world.Get_size() except ImportError: npes = 1 from . import _libwarpx class _MultiFABWrapper(object): """Wrapper around field arrays at level 0 This provides a convenient way to query and set fields that are broken up into FABs. The indexing is based on global indices. - direction: component to access, one of the values (0, 1, 2) or None - get_lovects: routine that returns the list of lo vectors - get_fabs: routine that returns the list of FABs - get_nodal_flag: routine that returns the list of nodal flag - level: refinement level """ def __init__(self, direction, get_lovects, get_fabs, get_nodal_flag, level, include_ghosts=False): self.direction = direction self.get_lovects = get_lovects self.get_fabs = get_fabs self.get_nodal_flag = get_nodal_flag self.level = level self.include_ghosts = include_ghosts self.dim = _libwarpx.dim # overlaps is one along the axes where the grid boundaries overlap the neighboring grid, # which is the case with node centering. # This presumably will never change during a calculation. self.overlaps = self.get_nodal_flag() def _getlovects(self): if self.direction is None: lovects, ngrow = self.get_lovects(self.level, self.include_ghosts) else: lovects, ngrow = self.get_lovects(self.level, self.direction, self.include_ghosts) return lovects, ngrow def _gethivects(self): lovects, ngrow = self._getlovects() fields = self._getfields() hivects = np.zeros_like(lovects) for i in range(len(fields)): hivects[:,i] = lovects[:,i] + np.array(fields[i].shape[:self.dim]) - self.overlaps return hivects, ngrow def _getfields(self): if self.direction is None: return self.get_fabs(self.level, self.include_ghosts) else: return self.get_fabs(self.level, self.direction, self.include_ghosts) def __len__(self): lovects, ngrow = self._getlovects() return len(lovects) def mesh(self, direction): """Returns the mesh along the specified direction with the appropriate centering. - direction: In 3d, one of 'x', 'y', or 'z'. In 2d, Cartesian, one of 'x', or 'z'. In RZ, one of 'r', or 'z' """ try: if _libwarpx.geometry_dim == '3d': idir = ['x', 'y', 'z'].index(direction) celldir = idir elif _libwarpx.geometry_dim == '2d': idir = ['x', 'z'].index(direction) celldir = 2*idir elif _libwarpx.geometry_dim == 'rz': idir = ['r', 'z'].index(direction) celldir = 2*idir except ValueError: raise Exception('Inappropriate direction given') # --- Get the total number of cells along the direction hivects, ngrow = self._gethivects() nn = hivects[idir,:].max() - ngrow[idir] + self.overlaps[idir] if npes > 1: nn = comm_world.allreduce(nn, op=mpi.MAX) # --- Cell size in the direction dd = _libwarpx.getCellSize(celldir, self.level) # --- Get the nodal flag along direction nodal_flag = self.get_nodal_flag()[idir] # --- The centering shift if nodal_flag == 1: # node centered shift = 0. else: # cell centered shift = 0.5*dd return np.arange(nn)*dd + shift def __getitem__(self, index): """Returns slices of a decomposed array, The shape of the object returned depends on the number of ix, iy and iz specified, which can be from none to all three. Note that the values of ix, iy and iz are relative to the fortran indexing, meaning that 0 is the lower boundary of the whole domain. """ if index == Ellipsis: index = tuple(self.dim*[slice(None)]) if len(index) < self.dim: # --- Add extra dims to index if needed index = list(index) for i in range(len(index), self.dim): index.append(slice(None)) index = tuple(index) if self.dim == 2: return self._getitem2d(index) elif self.dim == 3: return self._getitem3d(index) def _getitem3d(self, index): """Returns slices of a 3D decomposed array, """ lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() ix = index[0] iy = index[1] iz = index[2] if len(fields[0].shape) > self.dim: ncomps = fields[0].shape[-1] else: ncomps = 1 if len(index) > self.dim: if ncomps > 1: ic = index[-1] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] ny = hivects[1,:].max() - ngrow[1] nz = hivects[2,:].max() - ngrow[2] if npes > 1: nx = comm_world.allreduce(nx, op=mpi.MAX) ny = comm_world.allreduce(ny, op=mpi.MAX) nz = comm_world.allreduce(nz, op=mpi.MAX) if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iy, slice): iystart = max(iy.start or -ngrow[1], -ngrow[1]) iystop = min(iy.stop or ny + 1 + ngrow[1], ny + self.overlaps[1] + ngrow[1]) else: iystart = iy iystop = iy + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[2], -ngrow[2]) izstop = min(iz.stop or nz + 1 + ngrow[2], nz + self.overlaps[2] + ngrow[2]) else: izstart = iz izstop = iz + 1 # --- Setup the size of the array to be returned and create it. # --- Space is added for multiple components if needed. sss = (max(0, ixstop - ixstart), max(0, iystop - iystart), max(0, izstop - izstart)) if ncomps > 1 and ic is None: sss = tuple(list(sss) + [ncomps]) resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype) datalist = [] for i in range(len(fields)): # --- The ix1, 2 etc are relative to global indexing ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iy1 = max(iystart, lovects[1,i]) iy2 = min(iystop, lovects[1,i] + fields[i].shape[1]) iz1 = max(izstart, lovects[2,i]) iz2 = min(izstop, lovects[2,i] + fields[i].shape[2]) if ix1 < ix2 and iy1 < iy2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iy1 - lovects[1,i], iy2 - lovects[1,i]), slice(iz1 - lovects[2,i], iz2 - lovects[2,i])) if ic is not None: sss = tuple(list(sss) + [ic]) vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iy1 - iystart, iy2 - iystart), slice(iz1 - izstart, iz2 - izstart)) datalist.append((vslice, fields[i][sss])) if npes == 1: all_datalist = [datalist] else: all_datalist = comm_world.allgather(datalist) for datalist in all_datalist: for vslice, ff in datalist: resultglobal[vslice] = ff # --- Now remove any of the reduced dimensions. sss = [slice(None), slice(None), slice(None)] if not isinstance(ix, slice): sss[0] = 0 if not isinstance(iy, slice): sss[1] = 0 if not isinstance(iz, slice): sss[2] = 0 return resultglobal[tuple(sss)] def _getitem2d(self, index): """Returns slices of a 2D decomposed array, """ lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() ix = index[0] iz = index[1] if len(fields[0].shape) > self.dim: ncomps = fields[0].shape[-1] else: ncomps = 1 if len(index) > self.dim: if ncomps > 1: ic = index[2] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] nz = hivects[1,:].max() - ngrow[1] if npes > 1: nx = comm_world.allreduce(nx, op=mpi.MAX) nz = comm_world.allreduce(nz, op=mpi.MAX) if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[1], -ngrow[1]) izstop = min(iz.stop or nz + 1 + ngrow[1], nz + self.overlaps[1] + ngrow[1]) else: izstart = iz izstop = iz + 1 # --- Setup the size of the array to be returned and create it. # --- Space is added for multiple components if needed. sss = (max(0, ixstop - ixstart), max(0, izstop - izstart)) if ncomps > 1 and ic is None: sss = tuple(list(sss) + [ncomps]) resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype) datalist = [] for i in range(len(fields)): # --- The ix1, 2 etc are relative to global indexing ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iz1 = max(izstart, lovects[1,i]) iz2 = min(izstop, lovects[1,i] + fields[i].shape[1]) if ix1 < ix2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iz1 - lovects[1,i], iz2 - lovects[1,i])) if ic is not None: sss = tuple(list(sss) + [ic]) vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iz1 - izstart, iz2 - izstart)) datalist.append((vslice, fields[i][sss])) if npes == 1: all_datalist = [datalist] else: all_datalist = comm_world.allgather(datalist) for datalist in all_datalist: for vslice, ff in datalist: resultglobal[vslice] = ff # --- Now remove any of the reduced dimensions. sss = [slice(None), slice(None)] if not isinstance(ix, slice): sss[0] = 0 if not isinstance(iz, slice): sss[1] = 0 return resultglobal[tuple(sss)] def __setitem__(self, index, value): """Sets slices of a decomposed array. The shape of the input object depends on the number of arguments specified, which can be from none to all three. - value: input array (must be supplied) """ if index == Ellipsis: index = tuple(self.dim*[slice(None)]) if len(index) < self.dim: # --- Add extra dims to index if needed index = list(index) for i in range(len(index), self.dim): index.append(slice(None)) index = tuple(index) if self.dim == 2: return self._setitem2d(index, value) elif self.dim == 3: return self._setitem3d(index, value) def _setitem3d(self, index, value): """Sets slices of a decomposed 3D array. """ ix = index[0] iy = index[1] iz = index[2] lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() if len(index) > self.dim: if ncomps > 1: ic = index[-1] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] ny = hivects[1,:].max() - ngrow[1] nz = hivects[2,:].max() - ngrow[2] # --- Add extra dimensions so that the input has the same number of # --- dimensions as array. if isinstance(value, np.ndarray): value3d = np.array(value, copy=False) sss = list(value3d.shape) if not isinstance(ix, slice): sss[0:0] = [1] if not isinstance(iy, slice): sss[1:1] = [1] if not isinstance(iz, slice): sss[2:2] = [1] value3d.shape = sss if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iy, slice): iystart = max(iy.start or -ngrow[1], -ngrow[1]) iystop = min(iy.stop or ny + 1 + ngrow[1], ny + self.overlaps[1] + ngrow[1]) else: iystart = iy iystop = iy + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[2], -ngrow[2]) izstop = min(iz.stop or nz + 1 + ngrow[2], nz + self.overlaps[2] + ngrow[2]) else: izstart = iz izstop = iz + 1 for i in range(len(fields)): # --- The ix1, 2 etc are relative to global indexing ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iy1 = max(iystart, lovects[1,i]) iy2 = min(iystop, lovects[1,i] + fields[i].shape[1]) iz1 = max(izstart, lovects[2,i]) iz2 = min(izstop, lovects[2,i] + fields[i].shape[2]) if ix1 < ix2 and iy1 < iy2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iy1 - lovects[1,i], iy2 - lovects[1,i]), slice(iz1 - lovects[2,i], iz2 - lovects[2,i])) if ic is not None: sss = tuple(list(sss) + [ic]) if isinstance(value, np.ndarray): vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iy1 - iystart, iy2 - iystart), slice(iz1 - izstart, iz2 - izstart)) fields[i][sss] = value3d[vslice] else: fields[i][sss] = value def _setitem2d(self, index, value): """Sets slices of a decomposed 2D array. """ ix = index[0] iz = index[2] lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() if len(fields[0].shape) > self.dim: ncomps = fields[0].shape[-1] else: ncomps = 1 if len(index) > self.dim: if ncomps > 1: ic = index[2] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] nz = hivects[2,:].max() - ngrow[1] # --- Add extra dimensions so that the input has the same number of # --- dimensions as array. if isinstance(value, np.ndarray): value3d = np.array(value, copy=False) sss = list(value3d.shape) if not isinstance(ix, slice): sss[0:0] = [1] if not isinstance(iz, slice): sss[1:1] = [1] value3d.shape = sss if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[1], -ngrow[1]) izstop = min(iz.stop or nz + 1 + ngrow[1], nz + self.overlaps[2] + ngrow[1]) else: izstart = iz izstop = iz + 1 for i in range(len(fields)): # --- The ix1, 2 etc are relative to global indexing ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iz1 = max(izstart, lovects[2,i]) iz2 = min(izstop, lovects[2,i] + fields[i].shape[2]) if ix1 < ix2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iz1 - lovects[2,i], iz2 - lovects[2,i])) if ic is not None: sss = tuple(list(sss) + [ic]) if isinstance(value, np.ndarray): vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iz1 - izstart, iz2 - izstart)) fields[i][sss] = value3d[vslice] else: fields[i][sss] = value def ExWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_lovects, get_fabs=_libwarpx.get_mesh_electric_field, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_lovects, get_fabs=_libwarpx.get_mesh_electric_field, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_lovects, get_fabs=_libwarpx.get_mesh_electric_field, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_lovects, get_fabs=_libwarpx.get_mesh_current_density, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_lovects, get_fabs=_libwarpx.get_mesh_current_density, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_lovects, get_fabs=_libwarpx.get_mesh_current_density, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def ExCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_cp, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_cp, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_cp, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_cp, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_cp, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_cp, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects, get_fabs=_libwarpx.get_mesh_current_density_cp, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects, get_fabs=_libwarpx.get_mesh_current_density_cp, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects, get_fabs=_libwarpx.get_mesh_current_density_cp, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def RhoCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=None, get_lovects=_libwarpx.get_mesh_charge_density_cp_lovects, get_fabs=_libwarpx.get_mesh_charge_density_cp, get_nodal_flag=_libwarpx.get_Rho_nodal_flag, level=level, include_ghosts=include_ghosts) def ExFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_fp, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_fp, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_fp, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_fp, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_fp, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_fp, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects, get_fabs=_libwarpx.get_mesh_current_density_fp, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects, get_fabs=_libwarpx.get_mesh_current_density_fp, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects, get_fabs=_libwarpx.get_mesh_current_density_fp, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def RhoFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=None, get_lovects=_libwarpx.get_mesh_charge_density_fp_lovects, get_fabs=_libwarpx.get_mesh_charge_density_fp, get_nodal_flag=_libwarpx.get_Rho_nodal_flag, level=level, include_ghosts=include_ghosts) def ExCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_cp_pml, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_cp_pml, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_cp_pml, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_cp_pml, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_cp_pml, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_cp_pml, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_cp_pml, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_cp_pml, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_cp_pml, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def ExFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_fp_pml, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_fp_pml, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_fp_pml, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_fp_pml, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_fp_pml, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_fp_pml, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_fp_pml, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_fp_pml, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_fp_pml, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts)

44.255543

102

0.580141

import numpy as np try: from mpi4py import MPI as mpi comm_world = mpi.COMM_WORLD npes = comm_world.Get_size() except ImportError: npes = 1 from . import _libwarpx class _MultiFABWrapper(object): def __init__(self, direction, get_lovects, get_fabs, get_nodal_flag, level, include_ghosts=False): self.direction = direction self.get_lovects = get_lovects self.get_fabs = get_fabs self.get_nodal_flag = get_nodal_flag self.level = level self.include_ghosts = include_ghosts self.dim = _libwarpx.dim self.overlaps = self.get_nodal_flag() def _getlovects(self): if self.direction is None: lovects, ngrow = self.get_lovects(self.level, self.include_ghosts) else: lovects, ngrow = self.get_lovects(self.level, self.direction, self.include_ghosts) return lovects, ngrow def _gethivects(self): lovects, ngrow = self._getlovects() fields = self._getfields() hivects = np.zeros_like(lovects) for i in range(len(fields)): hivects[:,i] = lovects[:,i] + np.array(fields[i].shape[:self.dim]) - self.overlaps return hivects, ngrow def _getfields(self): if self.direction is None: return self.get_fabs(self.level, self.include_ghosts) else: return self.get_fabs(self.level, self.direction, self.include_ghosts) def __len__(self): lovects, ngrow = self._getlovects() return len(lovects) def mesh(self, direction): try: if _libwarpx.geometry_dim == '3d': idir = ['x', 'y', 'z'].index(direction) celldir = idir elif _libwarpx.geometry_dim == '2d': idir = ['x', 'z'].index(direction) celldir = 2*idir elif _libwarpx.geometry_dim == 'rz': idir = ['r', 'z'].index(direction) celldir = 2*idir except ValueError: raise Exception('Inappropriate direction given') hivects, ngrow = self._gethivects() nn = hivects[idir,:].max() - ngrow[idir] + self.overlaps[idir] if npes > 1: nn = comm_world.allreduce(nn, op=mpi.MAX) dd = _libwarpx.getCellSize(celldir, self.level) nodal_flag = self.get_nodal_flag()[idir] if nodal_flag == 1: shift = 0. else: shift = 0.5*dd return np.arange(nn)*dd + shift def __getitem__(self, index): if index == Ellipsis: index = tuple(self.dim*[slice(None)]) if len(index) < self.dim: index = list(index) for i in range(len(index), self.dim): index.append(slice(None)) index = tuple(index) if self.dim == 2: return self._getitem2d(index) elif self.dim == 3: return self._getitem3d(index) def _getitem3d(self, index): lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() ix = index[0] iy = index[1] iz = index[2] if len(fields[0].shape) > self.dim: ncomps = fields[0].shape[-1] else: ncomps = 1 if len(index) > self.dim: if ncomps > 1: ic = index[-1] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] ny = hivects[1,:].max() - ngrow[1] nz = hivects[2,:].max() - ngrow[2] if npes > 1: nx = comm_world.allreduce(nx, op=mpi.MAX) ny = comm_world.allreduce(ny, op=mpi.MAX) nz = comm_world.allreduce(nz, op=mpi.MAX) if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iy, slice): iystart = max(iy.start or -ngrow[1], -ngrow[1]) iystop = min(iy.stop or ny + 1 + ngrow[1], ny + self.overlaps[1] + ngrow[1]) else: iystart = iy iystop = iy + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[2], -ngrow[2]) izstop = min(iz.stop or nz + 1 + ngrow[2], nz + self.overlaps[2] + ngrow[2]) else: izstart = iz izstop = iz + 1 sss = (max(0, ixstop - ixstart), max(0, iystop - iystart), max(0, izstop - izstart)) if ncomps > 1 and ic is None: sss = tuple(list(sss) + [ncomps]) resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype) datalist = [] for i in range(len(fields)): ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iy1 = max(iystart, lovects[1,i]) iy2 = min(iystop, lovects[1,i] + fields[i].shape[1]) iz1 = max(izstart, lovects[2,i]) iz2 = min(izstop, lovects[2,i] + fields[i].shape[2]) if ix1 < ix2 and iy1 < iy2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iy1 - lovects[1,i], iy2 - lovects[1,i]), slice(iz1 - lovects[2,i], iz2 - lovects[2,i])) if ic is not None: sss = tuple(list(sss) + [ic]) vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iy1 - iystart, iy2 - iystart), slice(iz1 - izstart, iz2 - izstart)) datalist.append((vslice, fields[i][sss])) if npes == 1: all_datalist = [datalist] else: all_datalist = comm_world.allgather(datalist) for datalist in all_datalist: for vslice, ff in datalist: resultglobal[vslice] = ff sss = [slice(None), slice(None), slice(None)] if not isinstance(ix, slice): sss[0] = 0 if not isinstance(iy, slice): sss[1] = 0 if not isinstance(iz, slice): sss[2] = 0 return resultglobal[tuple(sss)] def _getitem2d(self, index): lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() ix = index[0] iz = index[1] if len(fields[0].shape) > self.dim: ncomps = fields[0].shape[-1] else: ncomps = 1 if len(index) > self.dim: if ncomps > 1: ic = index[2] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] nz = hivects[1,:].max() - ngrow[1] if npes > 1: nx = comm_world.allreduce(nx, op=mpi.MAX) nz = comm_world.allreduce(nz, op=mpi.MAX) if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[1], -ngrow[1]) izstop = min(iz.stop or nz + 1 + ngrow[1], nz + self.overlaps[1] + ngrow[1]) else: izstart = iz izstop = iz + 1 sss = (max(0, ixstop - ixstart), max(0, izstop - izstart)) if ncomps > 1 and ic is None: sss = tuple(list(sss) + [ncomps]) resultglobal = np.zeros(sss, dtype=_libwarpx._numpy_real_dtype) datalist = [] for i in range(len(fields)): ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iz1 = max(izstart, lovects[1,i]) iz2 = min(izstop, lovects[1,i] + fields[i].shape[1]) if ix1 < ix2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iz1 - lovects[1,i], iz2 - lovects[1,i])) if ic is not None: sss = tuple(list(sss) + [ic]) vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iz1 - izstart, iz2 - izstart)) datalist.append((vslice, fields[i][sss])) if npes == 1: all_datalist = [datalist] else: all_datalist = comm_world.allgather(datalist) for datalist in all_datalist: for vslice, ff in datalist: resultglobal[vslice] = ff sss = [slice(None), slice(None)] if not isinstance(ix, slice): sss[0] = 0 if not isinstance(iz, slice): sss[1] = 0 return resultglobal[tuple(sss)] def __setitem__(self, index, value): if index == Ellipsis: index = tuple(self.dim*[slice(None)]) if len(index) < self.dim: index = list(index) for i in range(len(index), self.dim): index.append(slice(None)) index = tuple(index) if self.dim == 2: return self._setitem2d(index, value) elif self.dim == 3: return self._setitem3d(index, value) def _setitem3d(self, index, value): ix = index[0] iy = index[1] iz = index[2] lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() if len(index) > self.dim: if ncomps > 1: ic = index[-1] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] ny = hivects[1,:].max() - ngrow[1] nz = hivects[2,:].max() - ngrow[2] if isinstance(value, np.ndarray): value3d = np.array(value, copy=False) sss = list(value3d.shape) if not isinstance(ix, slice): sss[0:0] = [1] if not isinstance(iy, slice): sss[1:1] = [1] if not isinstance(iz, slice): sss[2:2] = [1] value3d.shape = sss if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iy, slice): iystart = max(iy.start or -ngrow[1], -ngrow[1]) iystop = min(iy.stop or ny + 1 + ngrow[1], ny + self.overlaps[1] + ngrow[1]) else: iystart = iy iystop = iy + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[2], -ngrow[2]) izstop = min(iz.stop or nz + 1 + ngrow[2], nz + self.overlaps[2] + ngrow[2]) else: izstart = iz izstop = iz + 1 for i in range(len(fields)): ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iy1 = max(iystart, lovects[1,i]) iy2 = min(iystop, lovects[1,i] + fields[i].shape[1]) iz1 = max(izstart, lovects[2,i]) iz2 = min(izstop, lovects[2,i] + fields[i].shape[2]) if ix1 < ix2 and iy1 < iy2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iy1 - lovects[1,i], iy2 - lovects[1,i]), slice(iz1 - lovects[2,i], iz2 - lovects[2,i])) if ic is not None: sss = tuple(list(sss) + [ic]) if isinstance(value, np.ndarray): vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iy1 - iystart, iy2 - iystart), slice(iz1 - izstart, iz2 - izstart)) fields[i][sss] = value3d[vslice] else: fields[i][sss] = value def _setitem2d(self, index, value): ix = index[0] iz = index[2] lovects, ngrow = self._getlovects() hivects, ngrow = self._gethivects() fields = self._getfields() if len(fields[0].shape) > self.dim: ncomps = fields[0].shape[-1] else: ncomps = 1 if len(index) > self.dim: if ncomps > 1: ic = index[2] else: raise Exception('Too many indices given') else: ic = None nx = hivects[0,:].max() - ngrow[0] nz = hivects[2,:].max() - ngrow[1] if isinstance(value, np.ndarray): value3d = np.array(value, copy=False) sss = list(value3d.shape) if not isinstance(ix, slice): sss[0:0] = [1] if not isinstance(iz, slice): sss[1:1] = [1] value3d.shape = sss if isinstance(ix, slice): ixstart = max(ix.start or -ngrow[0], -ngrow[0]) ixstop = min(ix.stop or nx + 1 + ngrow[0], nx + self.overlaps[0] + ngrow[0]) else: ixstart = ix ixstop = ix + 1 if isinstance(iz, slice): izstart = max(iz.start or -ngrow[1], -ngrow[1]) izstop = min(iz.stop or nz + 1 + ngrow[1], nz + self.overlaps[2] + ngrow[1]) else: izstart = iz izstop = iz + 1 for i in range(len(fields)): ix1 = max(ixstart, lovects[0,i]) ix2 = min(ixstop, lovects[0,i] + fields[i].shape[0]) iz1 = max(izstart, lovects[2,i]) iz2 = min(izstop, lovects[2,i] + fields[i].shape[2]) if ix1 < ix2 and iz1 < iz2: sss = (slice(ix1 - lovects[0,i], ix2 - lovects[0,i]), slice(iz1 - lovects[2,i], iz2 - lovects[2,i])) if ic is not None: sss = tuple(list(sss) + [ic]) if isinstance(value, np.ndarray): vslice = (slice(ix1 - ixstart, ix2 - ixstart), slice(iz1 - izstart, iz2 - izstart)) fields[i][sss] = value3d[vslice] else: fields[i][sss] = value def ExWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_lovects, get_fabs=_libwarpx.get_mesh_electric_field, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_lovects, get_fabs=_libwarpx.get_mesh_electric_field, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_lovects, get_fabs=_libwarpx.get_mesh_electric_field, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_lovects, get_fabs=_libwarpx.get_mesh_current_density, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_lovects, get_fabs=_libwarpx.get_mesh_current_density, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_lovects, get_fabs=_libwarpx.get_mesh_current_density, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def ExCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_cp, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_cp, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_cp, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_cp, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_cp, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_cp, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects, get_fabs=_libwarpx.get_mesh_current_density_cp, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects, get_fabs=_libwarpx.get_mesh_current_density_cp, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects, get_fabs=_libwarpx.get_mesh_current_density_cp, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def RhoCPWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=None, get_lovects=_libwarpx.get_mesh_charge_density_cp_lovects, get_fabs=_libwarpx.get_mesh_charge_density_cp, get_nodal_flag=_libwarpx.get_Rho_nodal_flag, level=level, include_ghosts=include_ghosts) def ExFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_fp, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_fp, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects, get_fabs=_libwarpx.get_mesh_electric_field_fp, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_fp, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_fp, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects, get_fabs=_libwarpx.get_mesh_magnetic_field_fp, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects, get_fabs=_libwarpx.get_mesh_current_density_fp, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects, get_fabs=_libwarpx.get_mesh_current_density_fp, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects, get_fabs=_libwarpx.get_mesh_current_density_fp, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def RhoFPWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=None, get_lovects=_libwarpx.get_mesh_charge_density_fp_lovects, get_fabs=_libwarpx.get_mesh_charge_density_fp, get_nodal_flag=_libwarpx.get_Rho_nodal_flag, level=level, include_ghosts=include_ghosts) def ExCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_cp_pml, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_cp_pml, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_cp_pml, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_cp_pml, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_cp_pml, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_cp_pml, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_cp_pml, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_cp_pml, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzCPPMLWrapper(level=1, include_ghosts=False): assert level>0, Exception('Coarse patch only available on levels > 0') return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_cp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_cp_pml, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts) def ExFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_fp_pml, get_nodal_flag=_libwarpx.get_Ex_nodal_flag, level=level, include_ghosts=include_ghosts) def EyFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_fp_pml, get_nodal_flag=_libwarpx.get_Ey_nodal_flag, level=level, include_ghosts=include_ghosts) def EzFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_electric_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_electric_field_fp_pml, get_nodal_flag=_libwarpx.get_Ez_nodal_flag, level=level, include_ghosts=include_ghosts) def BxFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_fp_pml, get_nodal_flag=_libwarpx.get_Bx_nodal_flag, level=level, include_ghosts=include_ghosts) def ByFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_fp_pml, get_nodal_flag=_libwarpx.get_By_nodal_flag, level=level, include_ghosts=include_ghosts) def BzFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_magnetic_field_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_magnetic_field_fp_pml, get_nodal_flag=_libwarpx.get_Bz_nodal_flag, level=level, include_ghosts=include_ghosts) def JxFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=0, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_fp_pml, get_nodal_flag=_libwarpx.get_Jx_nodal_flag, level=level, include_ghosts=include_ghosts) def JyFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=1, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_fp_pml, get_nodal_flag=_libwarpx.get_Jy_nodal_flag, level=level, include_ghosts=include_ghosts) def JzFPPMLWrapper(level=0, include_ghosts=False): return _MultiFABWrapper(direction=2, get_lovects=_libwarpx.get_mesh_current_density_fp_lovects_pml, get_fabs=_libwarpx.get_mesh_current_density_fp_pml, get_nodal_flag=_libwarpx.get_Jz_nodal_flag, level=level, include_ghosts=include_ghosts)

true

f713205b80ac6e86e9fe43a9184bf463a0ecc8ca

916

py

Python

tests/memoize_test.py

silverbp/master-builder

9a9a53f8286e31888aaaee0cf52b555f8d41ce41

[ "Apache-2.0" ]

null

tests/memoize_test.py

silverbp/master-builder

9a9a53f8286e31888aaaee0cf52b555f8d41ce41

[ "Apache-2.0" ]

null

tests/memoize_test.py

silverbp/master-builder

9a9a53f8286e31888aaaee0cf52b555f8d41ce41

[ "Apache-2.0" ]

null

from __future__ import absolute_import from __future__ import unicode_literals from mb.lib.memoize import memoize class SomeClass: def __init__(self): self._x = 0 def _the_test(self, number): self._x += 1 return number * self._x @memoize def TestCache1(self, number): return self._the_test(number) @memoize("self", "number") def TestCache2(self, number, **kw): tmp = self._the_test(kw["number2"]) return self._the_test(tmp - number) def test_NoArgumentsPassed_UsesAllArgumentsForCache(): someClass = SomeClass() assert someClass._the_test(5) == 5 assert someClass.TestCache1(5) == 10 assert someClass.TestCache1(5) == 10 def test_ArgumentsPassedToUseForCache_UsesArgumentsForCache(): someClass = SomeClass() assert someClass.TestCache2(5, number2=10) == 10 assert someClass.TestCache2(5, number2=10) == 10

25.444444

62

0.691048

from __future__ import absolute_import from __future__ import unicode_literals from mb.lib.memoize import memoize class SomeClass: def __init__(self): self._x = 0 def _the_test(self, number): self._x += 1 return number * self._x @memoize def TestCache1(self, number): return self._the_test(number) @memoize("self", "number") def TestCache2(self, number, **kw): tmp = self._the_test(kw["number2"]) return self._the_test(tmp - number) def test_NoArgumentsPassed_UsesAllArgumentsForCache(): someClass = SomeClass() assert someClass._the_test(5) == 5 assert someClass.TestCache1(5) == 10 assert someClass.TestCache1(5) == 10 def test_ArgumentsPassedToUseForCache_UsesArgumentsForCache(): someClass = SomeClass() assert someClass.TestCache2(5, number2=10) == 10 assert someClass.TestCache2(5, number2=10) == 10

true

f71321067ba02bcf7949cc336b1f2f9ed37dd02d

1,546

py

Python

src/ssv/galah.py

einshoe/ssv-py

a13cdd05f695ec43cde4b4d2cbdaa2f97c98f497

[ "MIT" ]

null

src/ssv/galah.py

einshoe/ssv-py

a13cdd05f695ec43cde4b4d2cbdaa2f97c98f497

[ "MIT" ]

null

src/ssv/galah.py

einshoe/ssv-py

a13cdd05f695ec43cde4b4d2cbdaa2f97c98f497

[ "MIT" ]

null

import astropy.io.fits as fits from specutils import SpectrumList from specutils.io.registers import data_loader from .loaders import FITS_FILE_EXTS, SINGLE_SPLIT_LABEL GALAH_CONFIG = { "hdus": { "0": {"purpose": "science"}, "1": {"purpose": "error_stdev"}, "2": {"purpose": "unreduced_science"}, "3": {"purpose": "unreduced_error_stdev"}, "4": {"purpose": "skip"}, }, "wcs": { "pixel_reference_point_keyword": "CRPIX1", "pixel_reference_point_value_keyword": "CRVAL1", "pixel_width_keyword": "CDELT1", "wavelength_unit": "Angstrom", }, "units": {"flux_unit": "count"}, "all_standard_units": False, "all_keywords": False, "valid_wcs": False, } def identify_galah(origin, *args, **kwargs): """ Identify if the current file is a GALAH file """ file_obj = args[0] if isinstance(file_obj, fits.hdu.hdulist.HDUList): hdulist = file_obj else: hdulist = fits.open(file_obj, **kwargs) if "galah" in hdulist[0].header.get("REFERENC"): if not isinstance(file_obj, fits.hdu.hdulist.HDUList): hdulist.close() return True if not isinstance(file_obj, fits.hdu.hdulist.HDUList): hdulist.close() return False @data_loader( label="GALAH", extensions=FITS_FILE_EXTS, dtype=SpectrumList, identifier=identify_galah, ) def galah_loader(fname): spectra = SpectrumList.read( fname, format=SINGLE_SPLIT_LABEL, **GALAH_CONFIG ) return spectra

27.122807

65

0.635834

import astropy.io.fits as fits from specutils import SpectrumList from specutils.io.registers import data_loader from .loaders import FITS_FILE_EXTS, SINGLE_SPLIT_LABEL GALAH_CONFIG = { "hdus": { "0": {"purpose": "science"}, "1": {"purpose": "error_stdev"}, "2": {"purpose": "unreduced_science"}, "3": {"purpose": "unreduced_error_stdev"}, "4": {"purpose": "skip"}, }, "wcs": { "pixel_reference_point_keyword": "CRPIX1", "pixel_reference_point_value_keyword": "CRVAL1", "pixel_width_keyword": "CDELT1", "wavelength_unit": "Angstrom", }, "units": {"flux_unit": "count"}, "all_standard_units": False, "all_keywords": False, "valid_wcs": False, } def identify_galah(origin, *args, **kwargs): file_obj = args[0] if isinstance(file_obj, fits.hdu.hdulist.HDUList): hdulist = file_obj else: hdulist = fits.open(file_obj, **kwargs) if "galah" in hdulist[0].header.get("REFERENC"): if not isinstance(file_obj, fits.hdu.hdulist.HDUList): hdulist.close() return True if not isinstance(file_obj, fits.hdu.hdulist.HDUList): hdulist.close() return False @data_loader( label="GALAH", extensions=FITS_FILE_EXTS, dtype=SpectrumList, identifier=identify_galah, ) def galah_loader(fname): spectra = SpectrumList.read( fname, format=SINGLE_SPLIT_LABEL, **GALAH_CONFIG ) return spectra

true

f713218b3cfd005338a74b4f074bf114e52de19d

1,732

py

Python

python/dlbs/tests/test_config_caffe2.py

joehandzik/dlcookbook-dlbs

7c5ca5a6dfa4e2f7b8b4d81c60bd8be343dabd30

[ "Apache-2.0" ]

123

2017-11-28T20:21:24.000Z

2022-03-22T11:21:04.000Z

python/dlbs/tests/test_config_caffe2.py

joehandzik/dlcookbook-dlbs

7c5ca5a6dfa4e2f7b8b4d81c60bd8be343dabd30

[ "Apache-2.0" ]

17

2018-01-05T00:05:13.000Z

2020-09-18T05:12:45.000Z

python/dlbs/tests/test_config_caffe2.py

joehandzik/dlcookbook-dlbs

7c5ca5a6dfa4e2f7b8b4d81c60bd8be343dabd30

[ "Apache-2.0" ]

48

2018-01-04T20:52:51.000Z

2022-03-06T00:47:17.000Z

# (c) Copyright [2017] Hewlett Packard Enterprise Development LP # # 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. """Unit tests to verify all json configs can be parsed.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import unittest # append parent directory to import path import dlbs.tests.env # pylint: disable=W0611 from dlbs.tests.test_config_base import ConfigTester class TestConfigCaffe2(ConfigTester): def __init__(self, *args, **kwargs): ConfigTester.__init__(self, *args, **kwargs) def setUp(self): self.setUpBase(files=['base.json', 'caffe2.json']) def check_parameters(self, docker_image): self.build_plan({"exp.framework": "caffe2", "DLBS_ROOT": ""}) self.compute_vars( [], [("exp.framework_title", "Caffe2"), ("exp.framework_family", "caffe2"), ('exp.docker_image', docker_image), ('caffe2.docker_image', docker_image), ('runtime.EXPORT_CUDA_CACHE_PATH', 'CUDA_CACHE_PATH=/workspace/cuda_cache')] ) def test_docker_images(self): self.check_parameters('nvcr.io/nvidia/caffe2:18.05-py2') if __name__ == '__main__': unittest.main()

36.851064

89

0.714203

from __future__ import absolute_import from __future__ import division from __future__ import print_function import unittest import dlbs.tests.env from dlbs.tests.test_config_base import ConfigTester class TestConfigCaffe2(ConfigTester): def __init__(self, *args, **kwargs): ConfigTester.__init__(self, *args, **kwargs) def setUp(self): self.setUpBase(files=['base.json', 'caffe2.json']) def check_parameters(self, docker_image): self.build_plan({"exp.framework": "caffe2", "DLBS_ROOT": ""}) self.compute_vars( [], [("exp.framework_title", "Caffe2"), ("exp.framework_family", "caffe2"), ('exp.docker_image', docker_image), ('caffe2.docker_image', docker_image), ('runtime.EXPORT_CUDA_CACHE_PATH', 'CUDA_CACHE_PATH=/workspace/cuda_cache')] ) def test_docker_images(self): self.check_parameters('nvcr.io/nvidia/caffe2:18.05-py2') if __name__ == '__main__': unittest.main()

true

f71321cb54f24fb37ffa31ae550fc9b5d0aa94b2

12,683

py

Python

tensorflow_probability/python/distributions/skellam_test.py

brianwa84/probability

6f8e78d859ac41170be5147c8c7bde54cc5aa83e

[ "Apache-2.0" ]

1

2021-07-21T15:54:17.000Z

tensorflow_probability/python/distributions/skellam_test.py

brianwa84/probability

6f8e78d859ac41170be5147c8c7bde54cc5aa83e

[ "Apache-2.0" ]

null

tensorflow_probability/python/distributions/skellam_test.py

brianwa84/probability

6f8e78d859ac41170be5147c8c7bde54cc5aa83e

[ "Apache-2.0" ]

1

2020-10-19T11:24:40.000Z

# Copyright 2018 The TensorFlow Probability 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. # ============================================================================ from __future__ import absolute_import from __future__ import division from __future__ import print_function # Dependency imports import numpy as np from scipy import stats import tensorflow.compat.v2 as tf import tensorflow_probability as tfp from tensorflow_probability.python.internal import test_util tfd = tfp.distributions @test_util.test_all_tf_execution_regimes class _SkellamTest(object): def _make_skellam(self, rate1, rate2, validate_args=True, force_probs_to_zero_outside_support=False): return tfd.Skellam( rate1=rate1, rate2=rate2, validate_args=validate_args, force_probs_to_zero_outside_support=force_probs_to_zero_outside_support) def testSkellamShape(self): rate1 = tf.constant([3.0] * 5, dtype=self.dtype) rate2 = tf.constant([3.0] * 4, dtype=self.dtype)[..., tf.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertAllEqual(self.evaluate(skellam.batch_shape_tensor()), (4, 5)) self.assertEqual(skellam.batch_shape, tf.TensorShape([4, 5])) self.assertAllEqual(self.evaluate(skellam.event_shape_tensor()), []) self.assertEqual(skellam.event_shape, tf.TensorShape([])) def testInvalidLam(self): invalid_rate = self.dtype([-.01, 1., 2.]) valid_rate = self.dtype([1., 2., 3.]) with self.assertRaisesOpError('Argument `rate1` must be non-negative.'): skellam = self._make_skellam(rate1=invalid_rate, rate2=valid_rate) self.evaluate(skellam.rate1_parameter()) with self.assertRaisesOpError('Argument `rate2` must be non-negative.'): skellam = self._make_skellam(rate1=valid_rate, rate2=invalid_rate) self.evaluate(skellam.rate2_parameter()) def testZeroRate(self): lam = self.dtype(0.) skellam = tfd.Skellam(rate1=lam, rate2=lam, validate_args=True) self.assertAllClose(lam, self.evaluate(skellam.rate1)) self.assertAllClose(lam, self.evaluate(skellam.rate2)) self.assertAllClose(0., skellam.prob(3.)) self.assertAllClose(1., skellam.prob(0.)) self.assertAllClose(0., skellam.log_prob(0.)) def testSkellamLogPmfDiscreteMatchesScipy(self): batch_size = 12 rate1 = np.linspace(1, 12, 12).astype(self.dtype) rate2 = np.array([[1.2], [2.3]]).astype(self.dtype) x = np.array([-3., -1., 0., 2., 4., 3., 7., 4., 8., 9., 6., 7.], dtype=self.dtype) skellam = self._make_skellam( rate1=rate1, rate2=rate2, force_probs_to_zero_outside_support=True, validate_args=False) log_pmf = skellam.log_prob(x) self.assertEqual(log_pmf.shape, (2, batch_size)) self.assertAllClose( self.evaluate(log_pmf), stats.skellam.logpmf(x, rate1, rate2)) pmf = skellam.prob(x) self.assertEqual(pmf.shape, (2, batch_size,)) self.assertAllClose( self.evaluate(pmf), stats.skellam.pmf(x, rate1, rate2)) @test_util.numpy_disable_gradient_test def testSkellamLogPmfGradient(self): batch_size = 6 rate1 = tf.constant([3.] * batch_size, dtype=self.dtype) rate2 = tf.constant([2.7] * batch_size, dtype=self.dtype) x = np.array([-1., 2., 3., 4., 5., 6.], dtype=self.dtype) err = self.compute_max_gradient_error( lambda lam: self._make_skellam( # pylint:disable=g-long-lambda rate1=lam, rate2=rate2).log_prob(x), [rate1]) self.assertLess(err, 7e-4) err = self.compute_max_gradient_error( lambda lam: self._make_skellam( # pylint:disable=g-long-lambda rate1=rate1, rate2=lam).log_prob(x), [rate2]) self.assertLess(err, 7e-4) @test_util.numpy_disable_gradient_test def testSkellamLogPmfGradientAtZeroPmf(self): # Check that the derivative wrt parameter at the zero-prob points is zero. batch_size = 6 rate1 = tf.constant(np.linspace(1, 7, 6), dtype=self.dtype) rate2 = tf.constant(np.linspace(9.1, 12.1, 6), dtype=self.dtype) x = tf.constant([-2.1, -1.3, -0.5, 0.2, 1.5, 10.5], dtype=self.dtype) def make_skellam_log_prob(apply_to_second_rate=False): def skellam_log_prob(lam): return self._make_skellam( rate1=rate1 if apply_to_second_rate else lam, rate2=lam if apply_to_second_rate else rate2, force_probs_to_zero_outside_support=True, validate_args=False).log_prob(x) return skellam_log_prob _, dlog_pmf_dlam = self.evaluate(tfp.math.value_and_gradient( make_skellam_log_prob(), rate1)) self.assertEqual(dlog_pmf_dlam.shape, (batch_size,)) self.assertAllClose(dlog_pmf_dlam, np.zeros([batch_size])) _, dlog_pmf_dlam = self.evaluate(tfp.math.value_and_gradient( make_skellam_log_prob(True), rate2)) self.assertEqual(dlog_pmf_dlam.shape, (batch_size,)) self.assertAllClose(dlog_pmf_dlam, np.zeros([batch_size])) def testSkellamMean(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([5.0, 7.13, 2.56, 41.], dtype=self.dtype)[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertEqual(skellam.mean().shape, (4, 3)) self.assertAllClose( self.evaluate(skellam.mean()), stats.skellam.mean(rate1, rate2)) self.assertAllClose(self.evaluate(skellam.mean()), rate1 - rate2) def testSkellamVariance(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([5.0, 7.13, 2.56, 41.], dtype=self.dtype)[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertEqual(skellam.variance().shape, (4, 3)) self.assertAllClose( self.evaluate(skellam.variance()), stats.skellam.var(rate1, rate2)) self.assertAllClose(self.evaluate(skellam.variance()), rate1 + rate2) def testSkellamStd(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([5.0, 7.13, 2.56, 41.], dtype=self.dtype)[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertEqual(skellam.stddev().shape, (4, 3)) self.assertAllClose( self.evaluate(skellam.stddev()), stats.skellam.std(rate1, rate2)) self.assertAllClose(self.evaluate(skellam.stddev()), np.sqrt(rate1 + rate2)) def testSkellamSample(self): rate1 = self.dtype([2., 3., 4.]) rate2 = self.dtype([7.1, 3.2])[..., np.newaxis] n = int(2e5) skellam = self._make_skellam(rate1=rate1, rate2=rate2) samples = skellam.sample(n, seed=test_util.test_seed()) sample_values = self.evaluate(samples) self.assertEqual(samples.shape, (n, 2, 3)) self.assertEqual(sample_values.shape, (n, 2, 3)) self.assertAllClose( sample_values.mean(axis=0), stats.skellam.mean(rate1, rate2), rtol=.03) self.assertAllClose( sample_values.var(axis=0), stats.skellam.var(rate1, rate2), rtol=.03) def testAssertValidSample(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([2.1, 7.0, 42.5], dtype=self.dtype) skellam = self._make_skellam(rate1=rate1, rate2=rate2) with self.assertRaisesOpError('has non-integer components'): self.evaluate(skellam.prob([-1.2, 3., 4.2])) def testSkellamSampleMultidimensionalMean(self): rate1 = self.dtype([2., 3., 4., 5., 6.]) rate2 = self.dtype([7.1, 3.2, 10., 9.])[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) n = int(2e5) samples = skellam.sample(n, seed=test_util.test_seed()) sample_values = self.evaluate(samples) self.assertEqual(samples.shape, (n, 4, 5)) self.assertEqual(sample_values.shape, (n, 4, 5)) self.assertAllClose( sample_values.mean(axis=0), stats.skellam.mean(rate1, rate2), rtol=.04, atol=0) def testSkellamSampleMultidimensionalVariance(self): rate1 = self.dtype([2., 3., 4., 5., 6.]) rate2 = self.dtype([7.1, 3.2, 10., 9.])[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) n = int(1e5) samples = skellam.sample(n, seed=test_util.test_seed()) sample_values = self.evaluate(samples) self.assertEqual(samples.shape, (n, 4, 5)) self.assertEqual(sample_values.shape, (n, 4, 5)) self.assertAllClose( sample_values.var(axis=0), stats.skellam.var(rate1, rate2), rtol=.03, atol=0) @test_util.tf_tape_safety_test def testGradientThroughRate(self): rate1 = tf.Variable(3.) rate2 = tf.Variable(4.) dist = self._make_skellam(rate1=rate1, rate2=rate2) with tf.GradientTape() as tape: loss = -dist.log_prob([1., 2., 4.]) grad = tape.gradient(loss, dist.trainable_variables) self.assertLen(grad, 2) self.assertAllNotNone(grad) def testAssertsNonNegativeRate(self): rate1 = tf.Variable([-1., 2., -3.]) rate2 = tf.Variable([1., 2., 3.]) self.evaluate([rate1.initializer, rate2.initializer]) with self.assertRaisesOpError('Argument `rate1` must be non-negative.'): dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.sample(seed=test_util.test_seed())) rate1 = tf.Variable([1., 2., 3.]) rate2 = tf.Variable([-1., 2., -3.]) self.evaluate([rate1.initializer, rate2.initializer]) with self.assertRaisesOpError('Argument `rate2` must be non-negative.'): dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.sample(seed=test_util.test_seed())) def testAssertsNonNegativeRateAfterMutation(self): rate1 = tf.Variable([1., 2., 3.]) rate2 = tf.Variable([1., 2., 3.]) self.evaluate([rate1.initializer, rate2.initializer]) dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.mean()) with self.assertRaisesOpError('Argument `rate1` must be non-negative.'): with tf.control_dependencies([rate1.assign([1., 2., -3.])]): self.evaluate(dist.sample(seed=test_util.test_seed())) rate1 = tf.Variable([1., 2., 3.]) rate2 = tf.Variable([1., 2., 3.]) self.evaluate([rate1.initializer, rate2.initializer]) dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.mean()) with self.assertRaisesOpError('Argument `rate2` must be non-negative.'): with tf.control_dependencies([rate2.assign([1., 2., -3.])]): self.evaluate(dist.sample(seed=test_util.test_seed())) @test_util.test_all_tf_execution_regimes class SkellamTestFloat32(test_util.TestCase, _SkellamTest): dtype = np.float32 @test_util.test_all_tf_execution_regimes class SkellamTestFloat64(test_util.TestCase, _SkellamTest): dtype = np.float64 @test_util.test_all_tf_execution_regimes class SkellamLogRateTest(_SkellamTest): def _make_skellam(self, rate1, rate2, validate_args=True, force_probs_to_zero_outside_support=False): return tfd.Skellam( log_rate1=tf.math.log(rate1), log_rate2=tf.math.log(rate2), validate_args=validate_args, force_probs_to_zero_outside_support=force_probs_to_zero_outside_support) # No need to worry about the non-negativity of `rate` when using the # `log_rate` parameterization. def testInvalidLam(self): pass def testAssertsNonNegativeRate(self): pass def testAssertsNonNegativeRateAfterMutation(self): pass # The gradient is not tracked through tf.math.log(rate) in _make_skellam(), # so log_rate needs to be defined as a Variable and passed directly. @test_util.tf_tape_safety_test def testGradientThroughRate(self): log_rate1 = tf.Variable(3.) log_rate2 = tf.Variable(4.) dist = tfd.Skellam( log_rate1=log_rate1, log_rate2=log_rate2, validate_args=True) with tf.GradientTape() as tape: loss = -dist.log_prob([1., 2., 4.]) grad = tape.gradient(loss, dist.trainable_variables) self.assertLen(grad, 2) self.assertAllNotNone(grad) if __name__ == '__main__': tf.test.main()

39.883648

80

0.680754

from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np from scipy import stats import tensorflow.compat.v2 as tf import tensorflow_probability as tfp from tensorflow_probability.python.internal import test_util tfd = tfp.distributions @test_util.test_all_tf_execution_regimes class _SkellamTest(object): def _make_skellam(self, rate1, rate2, validate_args=True, force_probs_to_zero_outside_support=False): return tfd.Skellam( rate1=rate1, rate2=rate2, validate_args=validate_args, force_probs_to_zero_outside_support=force_probs_to_zero_outside_support) def testSkellamShape(self): rate1 = tf.constant([3.0] * 5, dtype=self.dtype) rate2 = tf.constant([3.0] * 4, dtype=self.dtype)[..., tf.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertAllEqual(self.evaluate(skellam.batch_shape_tensor()), (4, 5)) self.assertEqual(skellam.batch_shape, tf.TensorShape([4, 5])) self.assertAllEqual(self.evaluate(skellam.event_shape_tensor()), []) self.assertEqual(skellam.event_shape, tf.TensorShape([])) def testInvalidLam(self): invalid_rate = self.dtype([-.01, 1., 2.]) valid_rate = self.dtype([1., 2., 3.]) with self.assertRaisesOpError('Argument `rate1` must be non-negative.'): skellam = self._make_skellam(rate1=invalid_rate, rate2=valid_rate) self.evaluate(skellam.rate1_parameter()) with self.assertRaisesOpError('Argument `rate2` must be non-negative.'): skellam = self._make_skellam(rate1=valid_rate, rate2=invalid_rate) self.evaluate(skellam.rate2_parameter()) def testZeroRate(self): lam = self.dtype(0.) skellam = tfd.Skellam(rate1=lam, rate2=lam, validate_args=True) self.assertAllClose(lam, self.evaluate(skellam.rate1)) self.assertAllClose(lam, self.evaluate(skellam.rate2)) self.assertAllClose(0., skellam.prob(3.)) self.assertAllClose(1., skellam.prob(0.)) self.assertAllClose(0., skellam.log_prob(0.)) def testSkellamLogPmfDiscreteMatchesScipy(self): batch_size = 12 rate1 = np.linspace(1, 12, 12).astype(self.dtype) rate2 = np.array([[1.2], [2.3]]).astype(self.dtype) x = np.array([-3., -1., 0., 2., 4., 3., 7., 4., 8., 9., 6., 7.], dtype=self.dtype) skellam = self._make_skellam( rate1=rate1, rate2=rate2, force_probs_to_zero_outside_support=True, validate_args=False) log_pmf = skellam.log_prob(x) self.assertEqual(log_pmf.shape, (2, batch_size)) self.assertAllClose( self.evaluate(log_pmf), stats.skellam.logpmf(x, rate1, rate2)) pmf = skellam.prob(x) self.assertEqual(pmf.shape, (2, batch_size,)) self.assertAllClose( self.evaluate(pmf), stats.skellam.pmf(x, rate1, rate2)) @test_util.numpy_disable_gradient_test def testSkellamLogPmfGradient(self): batch_size = 6 rate1 = tf.constant([3.] * batch_size, dtype=self.dtype) rate2 = tf.constant([2.7] * batch_size, dtype=self.dtype) x = np.array([-1., 2., 3., 4., 5., 6.], dtype=self.dtype) err = self.compute_max_gradient_error( lambda lam: self._make_skellam( rate1=lam, rate2=rate2).log_prob(x), [rate1]) self.assertLess(err, 7e-4) err = self.compute_max_gradient_error( lambda lam: self._make_skellam( rate1=rate1, rate2=lam).log_prob(x), [rate2]) self.assertLess(err, 7e-4) @test_util.numpy_disable_gradient_test def testSkellamLogPmfGradientAtZeroPmf(self): batch_size = 6 rate1 = tf.constant(np.linspace(1, 7, 6), dtype=self.dtype) rate2 = tf.constant(np.linspace(9.1, 12.1, 6), dtype=self.dtype) x = tf.constant([-2.1, -1.3, -0.5, 0.2, 1.5, 10.5], dtype=self.dtype) def make_skellam_log_prob(apply_to_second_rate=False): def skellam_log_prob(lam): return self._make_skellam( rate1=rate1 if apply_to_second_rate else lam, rate2=lam if apply_to_second_rate else rate2, force_probs_to_zero_outside_support=True, validate_args=False).log_prob(x) return skellam_log_prob _, dlog_pmf_dlam = self.evaluate(tfp.math.value_and_gradient( make_skellam_log_prob(), rate1)) self.assertEqual(dlog_pmf_dlam.shape, (batch_size,)) self.assertAllClose(dlog_pmf_dlam, np.zeros([batch_size])) _, dlog_pmf_dlam = self.evaluate(tfp.math.value_and_gradient( make_skellam_log_prob(True), rate2)) self.assertEqual(dlog_pmf_dlam.shape, (batch_size,)) self.assertAllClose(dlog_pmf_dlam, np.zeros([batch_size])) def testSkellamMean(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([5.0, 7.13, 2.56, 41.], dtype=self.dtype)[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertEqual(skellam.mean().shape, (4, 3)) self.assertAllClose( self.evaluate(skellam.mean()), stats.skellam.mean(rate1, rate2)) self.assertAllClose(self.evaluate(skellam.mean()), rate1 - rate2) def testSkellamVariance(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([5.0, 7.13, 2.56, 41.], dtype=self.dtype)[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertEqual(skellam.variance().shape, (4, 3)) self.assertAllClose( self.evaluate(skellam.variance()), stats.skellam.var(rate1, rate2)) self.assertAllClose(self.evaluate(skellam.variance()), rate1 + rate2) def testSkellamStd(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([5.0, 7.13, 2.56, 41.], dtype=self.dtype)[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) self.assertEqual(skellam.stddev().shape, (4, 3)) self.assertAllClose( self.evaluate(skellam.stddev()), stats.skellam.std(rate1, rate2)) self.assertAllClose(self.evaluate(skellam.stddev()), np.sqrt(rate1 + rate2)) def testSkellamSample(self): rate1 = self.dtype([2., 3., 4.]) rate2 = self.dtype([7.1, 3.2])[..., np.newaxis] n = int(2e5) skellam = self._make_skellam(rate1=rate1, rate2=rate2) samples = skellam.sample(n, seed=test_util.test_seed()) sample_values = self.evaluate(samples) self.assertEqual(samples.shape, (n, 2, 3)) self.assertEqual(sample_values.shape, (n, 2, 3)) self.assertAllClose( sample_values.mean(axis=0), stats.skellam.mean(rate1, rate2), rtol=.03) self.assertAllClose( sample_values.var(axis=0), stats.skellam.var(rate1, rate2), rtol=.03) def testAssertValidSample(self): rate1 = np.array([1.0, 3.0, 2.5], dtype=self.dtype) rate2 = np.array([2.1, 7.0, 42.5], dtype=self.dtype) skellam = self._make_skellam(rate1=rate1, rate2=rate2) with self.assertRaisesOpError('has non-integer components'): self.evaluate(skellam.prob([-1.2, 3., 4.2])) def testSkellamSampleMultidimensionalMean(self): rate1 = self.dtype([2., 3., 4., 5., 6.]) rate2 = self.dtype([7.1, 3.2, 10., 9.])[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) n = int(2e5) samples = skellam.sample(n, seed=test_util.test_seed()) sample_values = self.evaluate(samples) self.assertEqual(samples.shape, (n, 4, 5)) self.assertEqual(sample_values.shape, (n, 4, 5)) self.assertAllClose( sample_values.mean(axis=0), stats.skellam.mean(rate1, rate2), rtol=.04, atol=0) def testSkellamSampleMultidimensionalVariance(self): rate1 = self.dtype([2., 3., 4., 5., 6.]) rate2 = self.dtype([7.1, 3.2, 10., 9.])[..., np.newaxis] skellam = self._make_skellam(rate1=rate1, rate2=rate2) n = int(1e5) samples = skellam.sample(n, seed=test_util.test_seed()) sample_values = self.evaluate(samples) self.assertEqual(samples.shape, (n, 4, 5)) self.assertEqual(sample_values.shape, (n, 4, 5)) self.assertAllClose( sample_values.var(axis=0), stats.skellam.var(rate1, rate2), rtol=.03, atol=0) @test_util.tf_tape_safety_test def testGradientThroughRate(self): rate1 = tf.Variable(3.) rate2 = tf.Variable(4.) dist = self._make_skellam(rate1=rate1, rate2=rate2) with tf.GradientTape() as tape: loss = -dist.log_prob([1., 2., 4.]) grad = tape.gradient(loss, dist.trainable_variables) self.assertLen(grad, 2) self.assertAllNotNone(grad) def testAssertsNonNegativeRate(self): rate1 = tf.Variable([-1., 2., -3.]) rate2 = tf.Variable([1., 2., 3.]) self.evaluate([rate1.initializer, rate2.initializer]) with self.assertRaisesOpError('Argument `rate1` must be non-negative.'): dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.sample(seed=test_util.test_seed())) rate1 = tf.Variable([1., 2., 3.]) rate2 = tf.Variable([-1., 2., -3.]) self.evaluate([rate1.initializer, rate2.initializer]) with self.assertRaisesOpError('Argument `rate2` must be non-negative.'): dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.sample(seed=test_util.test_seed())) def testAssertsNonNegativeRateAfterMutation(self): rate1 = tf.Variable([1., 2., 3.]) rate2 = tf.Variable([1., 2., 3.]) self.evaluate([rate1.initializer, rate2.initializer]) dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.mean()) with self.assertRaisesOpError('Argument `rate1` must be non-negative.'): with tf.control_dependencies([rate1.assign([1., 2., -3.])]): self.evaluate(dist.sample(seed=test_util.test_seed())) rate1 = tf.Variable([1., 2., 3.]) rate2 = tf.Variable([1., 2., 3.]) self.evaluate([rate1.initializer, rate2.initializer]) dist = self._make_skellam( rate1=rate1, rate2=rate2, validate_args=True) self.evaluate(dist.mean()) with self.assertRaisesOpError('Argument `rate2` must be non-negative.'): with tf.control_dependencies([rate2.assign([1., 2., -3.])]): self.evaluate(dist.sample(seed=test_util.test_seed())) @test_util.test_all_tf_execution_regimes class SkellamTestFloat32(test_util.TestCase, _SkellamTest): dtype = np.float32 @test_util.test_all_tf_execution_regimes class SkellamTestFloat64(test_util.TestCase, _SkellamTest): dtype = np.float64 @test_util.test_all_tf_execution_regimes class SkellamLogRateTest(_SkellamTest): def _make_skellam(self, rate1, rate2, validate_args=True, force_probs_to_zero_outside_support=False): return tfd.Skellam( log_rate1=tf.math.log(rate1), log_rate2=tf.math.log(rate2), validate_args=validate_args, force_probs_to_zero_outside_support=force_probs_to_zero_outside_support) def testInvalidLam(self): pass def testAssertsNonNegativeRate(self): pass def testAssertsNonNegativeRateAfterMutation(self): pass @test_util.tf_tape_safety_test def testGradientThroughRate(self): log_rate1 = tf.Variable(3.) log_rate2 = tf.Variable(4.) dist = tfd.Skellam( log_rate1=log_rate1, log_rate2=log_rate2, validate_args=True) with tf.GradientTape() as tape: loss = -dist.log_prob([1., 2., 4.]) grad = tape.gradient(loss, dist.trainable_variables) self.assertLen(grad, 2) self.assertAllNotNone(grad) if __name__ == '__main__': tf.test.main()

true

f713224a920d82d7746eced8e1f6f3c43bd3be3f

4,883

py

Python

app/main/views.py

hassan3111/Blog

62c00a40b693e44f1c88369592172af5477dc50a

[ "MIT" ]

null

app/main/views.py

hassan3111/Blog

62c00a40b693e44f1c88369592172af5477dc50a

[ "MIT" ]

null

app/main/views.py

hassan3111/Blog

62c00a40b693e44f1c88369592172af5477dc50a

[ "MIT" ]

null

from flask import render_template,request,url_for,redirect,flash,abort from . import main from .forms import BlogForm, CommentForm, UpdateProfile from ..models import User, Comment , Blog from flask_login import login_required, current_user from .. import db, photos import datetime from ..requests import getQuotes @main.route('/') def index(): ''' View root page function that returns the index page and its data ''' blogs = Blog.query.all() title = 'Home - Welcome to Blogs Online Website' quote = getQuotes() quote1 = getQuotes() quote2 = getQuotes() quote3 = getQuotes() return render_template('index.html', title = title, blogs=blogs, quote=quote ,quote1=quote1,quote2=quote2,quote3=quote3 ) @main.route('/blog/new', methods = ['GET','POST']) @login_required def new_blog(): blog_form = BlogForm() if blog_form.validate_on_submit(): title = blog_form.title.data blog = blog_form.text.data # Updated blog instance new_blog = Blog(blog_title=title,blog_content=blog,username=current_user.username,likes=0,dislikes=0) # Save blog method new_blog.save_blog() return redirect(url_for('.index')) title = 'New blog' return render_template('new_blog.html',title = title,blog_form=blog_form ) @main.route('/blog/<int:id>', methods = ['GET','POST']) def blog(id): blog = Blog.get_blog(id) posted_date = blog.posted.strftime('%b %d, %Y') if request.args.get("like"): blog.likes = blog.likes + 1 db.session.add(blog) db.session.commit() return redirect("/blog/{blog_id}".format(blog_id=blog.id)) elif request.args.get("dislike"): blog.dislikes = blog.dislikes + 1 db.session.add(blog) db.session.commit() return redirect("/blog/{blog_id}".format(blog_id=blog.id)) comment_form = CommentForm() if comment_form.validate_on_submit(): comment = comment_form.text.data new_comment = Comment(comment = comment,user = current_user,blog_id = blog) new_comment.save_comment() comments = Comment.get_comments(blog) return render_template("blog.html", blog = blog, date = posted_date, comment_form = comment_form, comments = comments) @main.route('/user/<uname>/blogs') def user_blogs(uname): user = User.query.filter_by(username=uname).first() blogs = Blog.query.filter_by(user_id = user.id).all() blogs_count = Blog.count_blogs(uname) user_joined = user.date_joined.strftime('%b,%d,%y') return render_template("profile/blogs.html",user = user, blogs = blogs, blogs_count= blogs_count,date= user_joined) @main.route('/user/<uname>') def profile(uname): user = User.query.filter_by(username = uname).first() if user is None: abort(404) return render_template("profile/profile.html", user = user) @main.route('/user/<uname>/update',methods = ['GET','POST']) @login_required def update_profile(uname): user = User.query.filter_by(username = uname).first() if user is None: abort(404) form = UpdateProfile() if form.validate_on_submit(): user.bio = form.bio.data db.session.add(user) db.session.commit() return redirect(url_for('.profile',uname=user.username)) return render_template('profile/update.html',form =form) @main.route("/blog/<int:id>/update",methods = ['GET','POST']) @login_required def update_blog(id): blog = Blog.query.get_or_404(id) if blog.username != current_user.username: abort(403) blog_form = BlogForm() if blog_form.validate_on_submit(): blog.blog_title = blog_form.title.data blog.blog_content = blog_form.text.data db.session.commit() flash('Your blog has been updated!', 'success') return redirect(url_for('main.blog', id=blog.id)) elif request.method == 'GET': blog_form.title.data = blog.blog_title blog_form.text.data = blog.blog_content return render_template('new_blog.html',title = 'Update Blog',blog_form=blog_form ) @main.route("/blog/<int:id>/delete", methods=['POST']) @login_required def delete_blog(id): blog = Blog.query.get(id) if blog.username != current_user.username: abort(403) db.session.delete(blog) db.session.commit() flash('Your post has been deleted!', 'success') return redirect(url_for('main.index')) @main.route('/user/<uname>/update/pic',methods= ['POST']) @login_required def update_pic(uname): user = User.query.filter_by(username = uname).first() if 'photo' in request.files: filename = photos.save(request.files['photo']) path = f'photos/{filename}' user.profile_pic_path = path db.session.commit() return redirect(url_for('main.profile',uname=uname))

30.329193

125

0.663936

from flask import render_template,request,url_for,redirect,flash,abort from . import main from .forms import BlogForm, CommentForm, UpdateProfile from ..models import User, Comment , Blog from flask_login import login_required, current_user from .. import db, photos import datetime from ..requests import getQuotes @main.route('/') def index(): blogs = Blog.query.all() title = 'Home - Welcome to Blogs Online Website' quote = getQuotes() quote1 = getQuotes() quote2 = getQuotes() quote3 = getQuotes() return render_template('index.html', title = title, blogs=blogs, quote=quote ,quote1=quote1,quote2=quote2,quote3=quote3 ) @main.route('/blog/new', methods = ['GET','POST']) @login_required def new_blog(): blog_form = BlogForm() if blog_form.validate_on_submit(): title = blog_form.title.data blog = blog_form.text.data new_blog = Blog(blog_title=title,blog_content=blog,username=current_user.username,likes=0,dislikes=0) new_blog.save_blog() return redirect(url_for('.index')) title = 'New blog' return render_template('new_blog.html',title = title,blog_form=blog_form ) @main.route('/blog/<int:id>', methods = ['GET','POST']) def blog(id): blog = Blog.get_blog(id) posted_date = blog.posted.strftime('%b %d, %Y') if request.args.get("like"): blog.likes = blog.likes + 1 db.session.add(blog) db.session.commit() return redirect("/blog/{blog_id}".format(blog_id=blog.id)) elif request.args.get("dislike"): blog.dislikes = blog.dislikes + 1 db.session.add(blog) db.session.commit() return redirect("/blog/{blog_id}".format(blog_id=blog.id)) comment_form = CommentForm() if comment_form.validate_on_submit(): comment = comment_form.text.data new_comment = Comment(comment = comment,user = current_user,blog_id = blog) new_comment.save_comment() comments = Comment.get_comments(blog) return render_template("blog.html", blog = blog, date = posted_date, comment_form = comment_form, comments = comments) @main.route('/user/<uname>/blogs') def user_blogs(uname): user = User.query.filter_by(username=uname).first() blogs = Blog.query.filter_by(user_id = user.id).all() blogs_count = Blog.count_blogs(uname) user_joined = user.date_joined.strftime('%b,%d,%y') return render_template("profile/blogs.html",user = user, blogs = blogs, blogs_count= blogs_count,date= user_joined) @main.route('/user/<uname>') def profile(uname): user = User.query.filter_by(username = uname).first() if user is None: abort(404) return render_template("profile/profile.html", user = user) @main.route('/user/<uname>/update',methods = ['GET','POST']) @login_required def update_profile(uname): user = User.query.filter_by(username = uname).first() if user is None: abort(404) form = UpdateProfile() if form.validate_on_submit(): user.bio = form.bio.data db.session.add(user) db.session.commit() return redirect(url_for('.profile',uname=user.username)) return render_template('profile/update.html',form =form) @main.route("/blog/<int:id>/update",methods = ['GET','POST']) @login_required def update_blog(id): blog = Blog.query.get_or_404(id) if blog.username != current_user.username: abort(403) blog_form = BlogForm() if blog_form.validate_on_submit(): blog.blog_title = blog_form.title.data blog.blog_content = blog_form.text.data db.session.commit() flash('Your blog has been updated!', 'success') return redirect(url_for('main.blog', id=blog.id)) elif request.method == 'GET': blog_form.title.data = blog.blog_title blog_form.text.data = blog.blog_content return render_template('new_blog.html',title = 'Update Blog',blog_form=blog_form ) @main.route("/blog/<int:id>/delete", methods=['POST']) @login_required def delete_blog(id): blog = Blog.query.get(id) if blog.username != current_user.username: abort(403) db.session.delete(blog) db.session.commit() flash('Your post has been deleted!', 'success') return redirect(url_for('main.index')) @main.route('/user/<uname>/update/pic',methods= ['POST']) @login_required def update_pic(uname): user = User.query.filter_by(username = uname).first() if 'photo' in request.files: filename = photos.save(request.files['photo']) path = f'photos/{filename}' user.profile_pic_path = path db.session.commit() return redirect(url_for('main.profile',uname=uname))

true

f713226757312973811f9826adebc138f959eef3

18,112

py

Python

__main__.py

ehrentim/Word-using-PySide2

d1d7f3fb1113995c1ec7e05a9d9c17c5cc501efe

[ "MIT" ]

null

__main__.py

ehrentim/Word-using-PySide2

d1d7f3fb1113995c1ec7e05a9d9c17c5cc501efe

[ "MIT" ]

null

__main__.py

ehrentim/Word-using-PySide2

d1d7f3fb1113995c1ec7e05a9d9c17c5cc501efe

[ "MIT" ]

null

from PyQt5.QtGui import QImage, QTextDocument, QIcon, QKeySequence, QFont from PyQt5.QtWidgets import QTextEdit, QApplication, QMainWindow, QAction, QMessageBox, QVBoxLayout, QWidget, \ QStatusBar, QToolBar, QFontComboBox, QComboBox, QActionGroup, QFileDialog, QColorDialog, QDialog, QStyle from PyQt5.QtCore import QSize, Qt from PyQt5.QtPrintSupport import QPrintDialog, QPrintPreviewDialog import os import sys import uuid # create function that returns resources when compiled with pyinstaller def get_resource(file: str) -> os.path: """ Get absolute path to resource, works for dev and for PyInstaller """ try: # PyInstaller creates a temp folder and stores path in _MEIPASS base_path = sys._MEIPASS except AttributeError: base_path = os.path.abspath(".") return os.path.join(base_path, file) FONT_SIZES = [7, 8, 9, 10, 11, 12, 13, 14, 18, 24, 36, 48, 64, 72, 96, 144, 288] IMAGE_EXTENSIONS = ['.jpg', '.png', '.bmp'] HTML_EXTENSIONS = ['.htm', '.html'] def hexuuid(): return uuid.uuid4().hex def splitext(p): return os.path.splitext(p)[1].lower() class TextEdit(QTextEdit): def canInsertFromMimeData(self, source): if source.hasImage(): return True else: return super(TextEdit, self).canInsertFromMimeData(source) def insertFromMimeData(self, source): cursor = self.textCursor() document = self.document() if source.hasUrls(): for u in source.urls(): file_ext = splitext(str(u.toLocalFile())) if u.isLocalFile() and file_ext in IMAGE_EXTENSIONS: image = QImage(u.toLocalFile()) document.addResource(QTextDocument.ImageResource, u, image) cursor.insertImage(u.toLocalFile()) else: # If we hit a non-image or non-local URL break the loop and fall out # to the super call & let Qt handle it break else: # If all were valid images, finish here. return elif source.hasImage(): image = source.imageData() uuid2 = hexuuid() document.addResource(QTextDocument.ImageResource, uuid2, image) cursor.insertImage(uuid2) return super(TextEdit, self).insertFromMimeData(source) class MainWindow(QMainWindow): def __init__(self, *args, **kwargs): super(MainWindow, self).__init__(*args, **kwargs) self.setWindowIcon(QIcon(get_resource("Icon.png"))) layout = QVBoxLayout() self.editor = TextEdit() # Setup the QTextEdit editor configuration self.editor.setAutoFormatting(QTextEdit.AutoAll) self.editor.selectionChanged.connect(self.update_format) # Initialize default font size. font = QFont('Times New Roman', 12) self.editor.setFont(font) # We need to repeat the size to init the current format. self.editor.setFontPointSize(12) # self.path holds the path of the currently open file. # If none, we haven't got a file open yet (or creating new). self.path = None layout.addWidget(self.editor) container = QWidget() container.setLayout(layout) self.setCentralWidget(container) self.status = QStatusBar() self.setStatusBar(self.status) # Uncomment to disable native menubar on Mac # self.menuBar().setNativeMenuBar(False) file_toolbar = QToolBar("File") file_toolbar.setIconSize(QSize(14, 14)) self.addToolBar(file_toolbar) file_menu = self.menuBar().addMenu("&Datei") open_file_action = QAction(QIcon(get_resource("blue-folder-open-document.png")), "Öffnen...", self) open_file_action.setStatusTip("Datei öffnen") open_file_action.setShortcut('Ctrl+O') open_file_action.triggered.connect(self.file_open) file_menu.addAction(open_file_action) file_toolbar.addAction(open_file_action) save_file_action = QAction(QIcon(get_resource('disk.png')), "Speichern", self) save_file_action.setStatusTip("Dokument speichern") save_file_action.setShortcut('Ctrl+S') save_file_action.triggered.connect(self.file_save) file_menu.addAction(save_file_action) file_toolbar.addAction(save_file_action) saveas_file_action = QAction(QIcon(get_resource('disk--pencil.png')), "Speichern unter...", self) saveas_file_action.setStatusTip("Dokument speichern unter") saveas_file_action.setShortcut('Ctrl+Shift+S') saveas_file_action.triggered.connect(self.file_saveas) file_menu.addAction(saveas_file_action) file_toolbar.addAction(saveas_file_action) print_action = QAction(QIcon(get_resource('printer.png')), "Drucken...", self) print_action.setStatusTip("Dokument drucken") print_action.setShortcut("Ctrl+P") print_action.triggered.connect(self.file_print) file_menu.addAction(print_action) file_toolbar.addAction(print_action) preview_action = QAction(QIcon(get_resource("print_preview.png")), "Druckvorschau", self) preview_action.setStatusTip("Druckvorschau") preview_action.setShortcut("Ctrl+Shift+P") preview_action.triggered.connect(self.preview) file_menu.addAction(preview_action) quit_action = QAction(QIcon(self.style().standardIcon(QStyle.SP_BrowserStop)), "Beenden", self) quit_action.setStatusTip("Word beenden") quit_action.setShortcut("Ctrl+Q") quit_action.triggered.connect(self.close) file_menu.addAction(quit_action) # file_toolbar.addAction(quit_action) edit_toolbar = QToolBar("Edit") edit_toolbar.setIconSize(QSize(16, 16)) self.addToolBar(edit_toolbar) edit_menu = self.menuBar().addMenu("&Bearbeiten") undo_action = QAction(QIcon(get_resource('arrow-curve-180-left.png')), "Rückgängig", self) undo_action.setStatusTip("letzte Änderung rückgängig machen") undo_action.setShortcut("Ctrl+Z") undo_action.triggered.connect(self.editor.undo) edit_menu.addAction(undo_action) edit_toolbar.addAction(undo_action) redo_action = QAction(QIcon(get_resource('arrow-curve.png')), "Wiederherstellen", self) redo_action.setStatusTip("letzte Änderung wiederherstellen") redo_action.setShortcut("Ctrl+Y") redo_action.triggered.connect(self.editor.redo) edit_toolbar.addAction(redo_action) edit_menu.addAction(redo_action) edit_menu.addSeparator() cut_action = QAction(QIcon(get_resource('scissors.png')), "Ausschneiden", self) cut_action.setStatusTip("markierten Text ausschneiden") # cut_action.setShortcut("Ctrl+X") cut_action.setShortcut(QKeySequence.Cut) cut_action.triggered.connect(self.editor.cut) # edit_toolbar.addAction(cut_action) edit_menu.addAction(cut_action) copy_action = QAction(QIcon(get_resource('document-copy.png')), "Kopieren", self) copy_action.setStatusTip("markierten Text kopieren") copy_action.setShortcut(QKeySequence.Copy) copy_action.triggered.connect(self.editor.copy) edit_toolbar.addAction(copy_action) edit_menu.addAction(copy_action) paste_action = QAction(QIcon(get_resource('clipboard-paste-document-text.png')), "Einfügen", self) paste_action.setStatusTip("einfügen aus der Zwischenablage") paste_action.setShortcut(QKeySequence.Paste) paste_action.triggered.connect(self.editor.paste) edit_toolbar.addAction(paste_action) edit_menu.addAction(paste_action) select_action = QAction(QIcon(get_resource('selection-input.png')), "Alles auswählen", self) select_action.setStatusTip("den gesamten Text auswählen") select_action.setShortcut(QKeySequence.SelectAll) select_action.triggered.connect(self.editor.selectAll) edit_menu.addAction(select_action) edit_menu.addSeparator() wrap_action = QAction("Wrap text to window", self) # QIcon(get_resource( 'arrow-continue.png')) wrap_action.setStatusTip("Toggle wrap text to window") wrap_action.setCheckable(True) wrap_action.setChecked(True) wrap_action.triggered.connect(self.edit_toggle_wrap) edit_menu.addAction(wrap_action) format_toolbar = QToolBar("Format") format_toolbar.setIconSize(QSize(16, 16)) self.addToolBar(format_toolbar) format_menu = self.menuBar().addMenu("&Format") # We need references to these actions/settings to update as selection changes, so attach to self. self.fonts = QFontComboBox() self.fonts.currentFontChanged.connect(self.editor.setCurrentFont) format_toolbar.addWidget(self.fonts) self.fontsize = QComboBox() self.fontsize.addItems([str(s) for s in FONT_SIZES]) # Connect to the signal producing the text of the current selection. Convert the string to float # and set as the pointsize. We could also use the index + retrieve from FONT_SIZES. self.fontsize.currentIndexChanged[str].connect(lambda s: self.editor.setFontPointSize(float(s))) format_toolbar.addWidget(self.fontsize) self.bold_action = QAction(QIcon(get_resource('edit-bold.png')), "Dick", self) self.bold_action.setStatusTip("Dick") self.bold_action.setShortcut(QKeySequence.Bold) self.bold_action.setCheckable(True) self.bold_action.toggled.connect(lambda x: self.editor.setFontWeight(QFont.Bold if x else QFont.Normal)) format_toolbar.addAction(self.bold_action) format_menu.addAction(self.bold_action) self.italic_action = QAction(QIcon(get_resource('edit-italic.png')), "Kursiv", self) self.italic_action.setStatusTip("Kursiv") self.italic_action.setShortcut(QKeySequence.Italic) self.italic_action.setCheckable(True) self.italic_action.toggled.connect(self.editor.setFontItalic) format_toolbar.addAction(self.italic_action) format_menu.addAction(self.italic_action) self.underline_action = QAction(QIcon(get_resource('edit-underline.png')), "Unterstriechen", self) self.underline_action.setStatusTip("Unterstriechen") self.underline_action.setShortcut(QKeySequence.Underline) self.underline_action.setCheckable(True) self.underline_action.toggled.connect(self.editor.setFontUnderline) format_toolbar.addAction(self.underline_action) format_menu.addAction(self.underline_action) self.color_menu = QAction(QIcon(get_resource("draw_color.png")), "Zeichenfarbe", self) self.color_menu.setStatusTip("Wähle eine Farbe mit der du schreiben kannst") self.color_menu.triggered.connect(self.chose_draw_color) format_menu.addAction(self.color_menu) format_toolbar.addAction(self.color_menu) format_menu.addSeparator() self.alignl_action = QAction(QIcon(get_resource('edit-alignment.png')), "Links ausrichten", self) self.alignl_action.setStatusTip("Links ausrichten") self.alignl_action.setShortcut("Ctrl+L") self.alignl_action.setCheckable(True) self.alignl_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignLeft)) format_toolbar.addAction(self.alignl_action) format_menu.addAction(self.alignl_action) self.alignc_action = QAction(QIcon(get_resource('edit-alignment-center.png')), "Zentriert ausrichten", self) self.alignc_action.setStatusTip("Zentriert ausrichten") self.alignc_action.setShortcut("Ctrl+E") self.alignc_action.setCheckable(True) self.alignc_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignCenter)) format_toolbar.addAction(self.alignc_action) format_menu.addAction(self.alignc_action) self.alignr_action = QAction(QIcon(get_resource('edit-alignment-right.png')), "Rechts ausrichten", self) self.alignr_action.setStatusTip("Rechts ausrichten") self.alignr_action.setShortcut("Ctrl+R") self.alignr_action.setCheckable(True) self.alignr_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignRight)) format_toolbar.addAction(self.alignr_action) format_menu.addAction(self.alignr_action) self.alignj_action = QAction(QIcon(get_resource('edit-alignment-justify.png')), "Blocksatz", self) self.alignj_action.setStatusTip("Blocksatz") self.alignj_action.setShortcut("Ctrl+B") self.alignj_action.setCheckable(True) self.alignj_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignJustify)) format_toolbar.addAction(self.alignj_action) format_menu.addAction(self.alignj_action) format_group = QActionGroup(self) format_group.setExclusive(True) format_group.addAction(self.alignl_action) format_group.addAction(self.alignc_action) format_group.addAction(self.alignr_action) format_group.addAction(self.alignj_action) format_menu.addSeparator() # A list of all format-related widgets/actions, so we can disable/enable signals when updating. self._format_actions = [ self.fonts, self.fontsize, self.bold_action, self.italic_action, self.underline_action, # We don't need to disable signals for alignment, as they are paragraph-wide. ] # Initialize. self.update_format() self.update_title() self.show() # Tests self.editor.textChanged.connect(self.update_title_chanced) # self.editor.setTextColor(QColorDialog(self).getColor(Qt.black, self)) def block_signals(self, objects, b): for o in objects: o.blockSignals(b) def update_format(self): """ Update the font format toolbar/actions when a new text selection is made. This is neccessary to keep toolbars/etc. in sync with the current edit state. :return: """ # Disable signals for all format widgets, so changing values here does not trigger further formatting. self.block_signals(self._format_actions, True) self.fonts.setCurrentFont(self.editor.currentFont()) # Nasty, but we get the font-size as a float but want it was an int self.fontsize.setCurrentText(str(int(self.editor.fontPointSize()))) self.italic_action.setChecked(self.editor.fontItalic()) self.underline_action.setChecked(self.editor.fontUnderline()) self.bold_action.setChecked(self.editor.fontWeight() == QFont.Bold) self.alignl_action.setChecked(self.editor.alignment() == Qt.AlignLeft) self.alignc_action.setChecked(self.editor.alignment() == Qt.AlignCenter) self.alignr_action.setChecked(self.editor.alignment() == Qt.AlignRight) self.alignj_action.setChecked(self.editor.alignment() == Qt.AlignJustify) self.block_signals(self._format_actions, False) def dialog_critical(self, s): dlg = QMessageBox(self) dlg.setText(s) dlg.setIcon(QMessageBox.Critical) dlg.show() def file_open(self): path, _ = QFileDialog.getOpenFileName(self, "Open file", "", "HTML documents (*.html);Text documents (*.txt);All files (*.*)") try: with open(path, 'r') as f: text = f.read() except Exception as e: self.dialog_critical(str(e)) else: self.path = path # Qt will automatically try and guess the format as txt/html self.editor.setText(text) self.update_title() def file_save(self): if self.path is None: # If we do not have a path, we need to use Save As. return self.file_saveas() text = self.editor.toHtml() if splitext(self.path) in HTML_EXTENSIONS else self.editor.toPlainText() try: with open(self.path, 'w') as f: f.write(text) except Exception as e: self.dialog_critical(str(e)) def file_saveas(self): path, _ = QFileDialog.getSaveFileName(self, "Save file", "", "WORD documents (*.word);HTML documents (*.html);Text documents (*.txt);All files (*.*)") if not path: # If dialog is cancelled, will return '' return text = self.editor.toHtml() if splitext(path) in HTML_EXTENSIONS else self.editor.toPlainText() try: with open(path, 'w') as f: f.write(text) except Exception as e: self.dialog_critical(str(e)) else: self.path = path self.update_title() def file_print(self): dlg = QPrintDialog() if dlg.exec() == QDialog.Accepted: self.editor.print(dlg.printer()) def preview(self): dlg = QPrintPreviewDialog() dlg.paintRequested.connect(self.editor.print) dlg.exec() def chose_draw_color(self): self.editor.setTextColor(QColorDialog(self).getColor(self.editor.textColor(), self, "Zeichenfarbe")) def update_title(self): self.setWindowTitle("%s - Word" % (os.path.basename(self.path) if self.path else "Unbenannt")) def update_title_chanced(self): self.setWindowTitle("*%s - Word" % (os.path.basename(self.path) if self.path else "Unbenannt")) def edit_toggle_wrap(self): self.editor.setLineWrapMode(1 if self.editor.lineWrapMode() == 0 else 0) if __name__ == '__main__': app = QApplication(sys.argv) app.setApplicationName("Word") window = MainWindow() app.exec_()

40.701124

135

0.669943

from PyQt5.QtGui import QImage, QTextDocument, QIcon, QKeySequence, QFont from PyQt5.QtWidgets import QTextEdit, QApplication, QMainWindow, QAction, QMessageBox, QVBoxLayout, QWidget, \ QStatusBar, QToolBar, QFontComboBox, QComboBox, QActionGroup, QFileDialog, QColorDialog, QDialog, QStyle from PyQt5.QtCore import QSize, Qt from PyQt5.QtPrintSupport import QPrintDialog, QPrintPreviewDialog import os import sys import uuid def get_resource(file: str) -> os.path: try: base_path = sys._MEIPASS except AttributeError: base_path = os.path.abspath(".") return os.path.join(base_path, file) FONT_SIZES = [7, 8, 9, 10, 11, 12, 13, 14, 18, 24, 36, 48, 64, 72, 96, 144, 288] IMAGE_EXTENSIONS = ['.jpg', '.png', '.bmp'] HTML_EXTENSIONS = ['.htm', '.html'] def hexuuid(): return uuid.uuid4().hex def splitext(p): return os.path.splitext(p)[1].lower() class TextEdit(QTextEdit): def canInsertFromMimeData(self, source): if source.hasImage(): return True else: return super(TextEdit, self).canInsertFromMimeData(source) def insertFromMimeData(self, source): cursor = self.textCursor() document = self.document() if source.hasUrls(): for u in source.urls(): file_ext = splitext(str(u.toLocalFile())) if u.isLocalFile() and file_ext in IMAGE_EXTENSIONS: image = QImage(u.toLocalFile()) document.addResource(QTextDocument.ImageResource, u, image) cursor.insertImage(u.toLocalFile()) else: break else: return elif source.hasImage(): image = source.imageData() uuid2 = hexuuid() document.addResource(QTextDocument.ImageResource, uuid2, image) cursor.insertImage(uuid2) return super(TextEdit, self).insertFromMimeData(source) class MainWindow(QMainWindow): def __init__(self, *args, **kwargs): super(MainWindow, self).__init__(*args, **kwargs) self.setWindowIcon(QIcon(get_resource("Icon.png"))) layout = QVBoxLayout() self.editor = TextEdit() self.editor.setAutoFormatting(QTextEdit.AutoAll) self.editor.selectionChanged.connect(self.update_format) font = QFont('Times New Roman', 12) self.editor.setFont(font) self.editor.setFontPointSize(12) self.path = None layout.addWidget(self.editor) container = QWidget() container.setLayout(layout) self.setCentralWidget(container) self.status = QStatusBar() self.setStatusBar(self.status) # Uncomment to disable native menubar on Mac # self.menuBar().setNativeMenuBar(False) file_toolbar = QToolBar("File") file_toolbar.setIconSize(QSize(14, 14)) self.addToolBar(file_toolbar) file_menu = self.menuBar().addMenu("&Datei") open_file_action = QAction(QIcon(get_resource("blue-folder-open-document.png")), "Öffnen...", self) open_file_action.setStatusTip("Datei öffnen") open_file_action.setShortcut('Ctrl+O') open_file_action.triggered.connect(self.file_open) file_menu.addAction(open_file_action) file_toolbar.addAction(open_file_action) save_file_action = QAction(QIcon(get_resource('disk.png')), "Speichern", self) save_file_action.setStatusTip("Dokument speichern") save_file_action.setShortcut('Ctrl+S') save_file_action.triggered.connect(self.file_save) file_menu.addAction(save_file_action) file_toolbar.addAction(save_file_action) saveas_file_action = QAction(QIcon(get_resource('disk--pencil.png')), "Speichern unter...", self) saveas_file_action.setStatusTip("Dokument speichern unter") saveas_file_action.setShortcut('Ctrl+Shift+S') saveas_file_action.triggered.connect(self.file_saveas) file_menu.addAction(saveas_file_action) file_toolbar.addAction(saveas_file_action) print_action = QAction(QIcon(get_resource('printer.png')), "Drucken...", self) print_action.setStatusTip("Dokument drucken") print_action.setShortcut("Ctrl+P") print_action.triggered.connect(self.file_print) file_menu.addAction(print_action) file_toolbar.addAction(print_action) preview_action = QAction(QIcon(get_resource("print_preview.png")), "Druckvorschau", self) preview_action.setStatusTip("Druckvorschau") preview_action.setShortcut("Ctrl+Shift+P") preview_action.triggered.connect(self.preview) file_menu.addAction(preview_action) quit_action = QAction(QIcon(self.style().standardIcon(QStyle.SP_BrowserStop)), "Beenden", self) quit_action.setStatusTip("Word beenden") quit_action.setShortcut("Ctrl+Q") quit_action.triggered.connect(self.close) file_menu.addAction(quit_action) # file_toolbar.addAction(quit_action) edit_toolbar = QToolBar("Edit") edit_toolbar.setIconSize(QSize(16, 16)) self.addToolBar(edit_toolbar) edit_menu = self.menuBar().addMenu("&Bearbeiten") undo_action = QAction(QIcon(get_resource('arrow-curve-180-left.png')), "Rückgängig", self) undo_action.setStatusTip("letzte Änderung rückgängig machen") undo_action.setShortcut("Ctrl+Z") undo_action.triggered.connect(self.editor.undo) edit_menu.addAction(undo_action) edit_toolbar.addAction(undo_action) redo_action = QAction(QIcon(get_resource('arrow-curve.png')), "Wiederherstellen", self) redo_action.setStatusTip("letzte Änderung wiederherstellen") redo_action.setShortcut("Ctrl+Y") redo_action.triggered.connect(self.editor.redo) edit_toolbar.addAction(redo_action) edit_menu.addAction(redo_action) edit_menu.addSeparator() cut_action = QAction(QIcon(get_resource('scissors.png')), "Ausschneiden", self) cut_action.setStatusTip("markierten Text ausschneiden") # cut_action.setShortcut("Ctrl+X") cut_action.setShortcut(QKeySequence.Cut) cut_action.triggered.connect(self.editor.cut) # edit_toolbar.addAction(cut_action) edit_menu.addAction(cut_action) copy_action = QAction(QIcon(get_resource('document-copy.png')), "Kopieren", self) copy_action.setStatusTip("markierten Text kopieren") copy_action.setShortcut(QKeySequence.Copy) copy_action.triggered.connect(self.editor.copy) edit_toolbar.addAction(copy_action) edit_menu.addAction(copy_action) paste_action = QAction(QIcon(get_resource('clipboard-paste-document-text.png')), "Einfügen", self) paste_action.setStatusTip("einfügen aus der Zwischenablage") paste_action.setShortcut(QKeySequence.Paste) paste_action.triggered.connect(self.editor.paste) edit_toolbar.addAction(paste_action) edit_menu.addAction(paste_action) select_action = QAction(QIcon(get_resource('selection-input.png')), "Alles auswählen", self) select_action.setStatusTip("den gesamten Text auswählen") select_action.setShortcut(QKeySequence.SelectAll) select_action.triggered.connect(self.editor.selectAll) edit_menu.addAction(select_action) edit_menu.addSeparator() wrap_action = QAction("Wrap text to window", self) # QIcon(get_resource( 'arrow-continue.png')) wrap_action.setStatusTip("Toggle wrap text to window") wrap_action.setCheckable(True) wrap_action.setChecked(True) wrap_action.triggered.connect(self.edit_toggle_wrap) edit_menu.addAction(wrap_action) format_toolbar = QToolBar("Format") format_toolbar.setIconSize(QSize(16, 16)) self.addToolBar(format_toolbar) format_menu = self.menuBar().addMenu("&Format") # We need references to these actions/settings to update as selection changes, so attach to self. self.fonts = QFontComboBox() self.fonts.currentFontChanged.connect(self.editor.setCurrentFont) format_toolbar.addWidget(self.fonts) self.fontsize = QComboBox() self.fontsize.addItems([str(s) for s in FONT_SIZES]) # Connect to the signal producing the text of the current selection. Convert the string to float # and set as the pointsize. We could also use the index + retrieve from FONT_SIZES. self.fontsize.currentIndexChanged[str].connect(lambda s: self.editor.setFontPointSize(float(s))) format_toolbar.addWidget(self.fontsize) self.bold_action = QAction(QIcon(get_resource('edit-bold.png')), "Dick", self) self.bold_action.setStatusTip("Dick") self.bold_action.setShortcut(QKeySequence.Bold) self.bold_action.setCheckable(True) self.bold_action.toggled.connect(lambda x: self.editor.setFontWeight(QFont.Bold if x else QFont.Normal)) format_toolbar.addAction(self.bold_action) format_menu.addAction(self.bold_action) self.italic_action = QAction(QIcon(get_resource('edit-italic.png')), "Kursiv", self) self.italic_action.setStatusTip("Kursiv") self.italic_action.setShortcut(QKeySequence.Italic) self.italic_action.setCheckable(True) self.italic_action.toggled.connect(self.editor.setFontItalic) format_toolbar.addAction(self.italic_action) format_menu.addAction(self.italic_action) self.underline_action = QAction(QIcon(get_resource('edit-underline.png')), "Unterstriechen", self) self.underline_action.setStatusTip("Unterstriechen") self.underline_action.setShortcut(QKeySequence.Underline) self.underline_action.setCheckable(True) self.underline_action.toggled.connect(self.editor.setFontUnderline) format_toolbar.addAction(self.underline_action) format_menu.addAction(self.underline_action) self.color_menu = QAction(QIcon(get_resource("draw_color.png")), "Zeichenfarbe", self) self.color_menu.setStatusTip("Wähle eine Farbe mit der du schreiben kannst") self.color_menu.triggered.connect(self.chose_draw_color) format_menu.addAction(self.color_menu) format_toolbar.addAction(self.color_menu) format_menu.addSeparator() self.alignl_action = QAction(QIcon(get_resource('edit-alignment.png')), "Links ausrichten", self) self.alignl_action.setStatusTip("Links ausrichten") self.alignl_action.setShortcut("Ctrl+L") self.alignl_action.setCheckable(True) self.alignl_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignLeft)) format_toolbar.addAction(self.alignl_action) format_menu.addAction(self.alignl_action) self.alignc_action = QAction(QIcon(get_resource('edit-alignment-center.png')), "Zentriert ausrichten", self) self.alignc_action.setStatusTip("Zentriert ausrichten") self.alignc_action.setShortcut("Ctrl+E") self.alignc_action.setCheckable(True) self.alignc_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignCenter)) format_toolbar.addAction(self.alignc_action) format_menu.addAction(self.alignc_action) self.alignr_action = QAction(QIcon(get_resource('edit-alignment-right.png')), "Rechts ausrichten", self) self.alignr_action.setStatusTip("Rechts ausrichten") self.alignr_action.setShortcut("Ctrl+R") self.alignr_action.setCheckable(True) self.alignr_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignRight)) format_toolbar.addAction(self.alignr_action) format_menu.addAction(self.alignr_action) self.alignj_action = QAction(QIcon(get_resource('edit-alignment-justify.png')), "Blocksatz", self) self.alignj_action.setStatusTip("Blocksatz") self.alignj_action.setShortcut("Ctrl+B") self.alignj_action.setCheckable(True) self.alignj_action.triggered.connect(lambda: self.editor.setAlignment(Qt.AlignJustify)) format_toolbar.addAction(self.alignj_action) format_menu.addAction(self.alignj_action) format_group = QActionGroup(self) format_group.setExclusive(True) format_group.addAction(self.alignl_action) format_group.addAction(self.alignc_action) format_group.addAction(self.alignr_action) format_group.addAction(self.alignj_action) format_menu.addSeparator() # A list of all format-related widgets/actions, so we can disable/enable signals when updating. self._format_actions = [ self.fonts, self.fontsize, self.bold_action, self.italic_action, self.underline_action, # We don't need to disable signals for alignment, as they are paragraph-wide. ] self.update_format() self.update_title() self.show() self.editor.textChanged.connect(self.update_title_chanced) def block_signals(self, objects, b): for o in objects: o.blockSignals(b) def update_format(self): self.block_signals(self._format_actions, True) self.fonts.setCurrentFont(self.editor.currentFont()) self.fontsize.setCurrentText(str(int(self.editor.fontPointSize()))) self.italic_action.setChecked(self.editor.fontItalic()) self.underline_action.setChecked(self.editor.fontUnderline()) self.bold_action.setChecked(self.editor.fontWeight() == QFont.Bold) self.alignl_action.setChecked(self.editor.alignment() == Qt.AlignLeft) self.alignc_action.setChecked(self.editor.alignment() == Qt.AlignCenter) self.alignr_action.setChecked(self.editor.alignment() == Qt.AlignRight) self.alignj_action.setChecked(self.editor.alignment() == Qt.AlignJustify) self.block_signals(self._format_actions, False) def dialog_critical(self, s): dlg = QMessageBox(self) dlg.setText(s) dlg.setIcon(QMessageBox.Critical) dlg.show() def file_open(self): path, _ = QFileDialog.getOpenFileName(self, "Open file", "", "HTML documents (*.html);Text documents (*.txt);All files (*.*)") try: with open(path, 'r') as f: text = f.read() except Exception as e: self.dialog_critical(str(e)) else: self.path = path self.editor.setText(text) self.update_title() def file_save(self): if self.path is None: return self.file_saveas() text = self.editor.toHtml() if splitext(self.path) in HTML_EXTENSIONS else self.editor.toPlainText() try: with open(self.path, 'w') as f: f.write(text) except Exception as e: self.dialog_critical(str(e)) def file_saveas(self): path, _ = QFileDialog.getSaveFileName(self, "Save file", "", "WORD documents (*.word);HTML documents (*.html);Text documents (*.txt);All files (*.*)") if not path: return text = self.editor.toHtml() if splitext(path) in HTML_EXTENSIONS else self.editor.toPlainText() try: with open(path, 'w') as f: f.write(text) except Exception as e: self.dialog_critical(str(e)) else: self.path = path self.update_title() def file_print(self): dlg = QPrintDialog() if dlg.exec() == QDialog.Accepted: self.editor.print(dlg.printer()) def preview(self): dlg = QPrintPreviewDialog() dlg.paintRequested.connect(self.editor.print) dlg.exec() def chose_draw_color(self): self.editor.setTextColor(QColorDialog(self).getColor(self.editor.textColor(), self, "Zeichenfarbe")) def update_title(self): self.setWindowTitle("%s - Word" % (os.path.basename(self.path) if self.path else "Unbenannt")) def update_title_chanced(self): self.setWindowTitle("*%s - Word" % (os.path.basename(self.path) if self.path else "Unbenannt")) def edit_toggle_wrap(self): self.editor.setLineWrapMode(1 if self.editor.lineWrapMode() == 0 else 0) if __name__ == '__main__': app = QApplication(sys.argv) app.setApplicationName("Word") window = MainWindow() app.exec_()

true

f7132272a08ae3ff742cc72c8c3f38c04039858e

16,593

py

Python

tensorflow_model_optimization/python/core/quantization/keras/collaborative_optimizations/cluster_preserve/cluster_preserve_quantize_registry.py

Pandinosaurus/model-optimization

12dc84dd34ee3c6eb08b381c0abcd65b31a42366

[ "Apache-2.0" ]

1,318

2018-10-31T23:57:52.000Z

2022-03-30T11:07:40.000Z

tensorflow_model_optimization/python/core/quantization/keras/collaborative_optimizations/cluster_preserve/cluster_preserve_quantize_registry.py

Pandinosaurus/model-optimization

12dc84dd34ee3c6eb08b381c0abcd65b31a42366

[ "Apache-2.0" ]

410

2019-05-15T14:11:13.000Z

2022-03-31T07:27:07.000Z

tensorflow_model_optimization/python/core/quantization/keras/collaborative_optimizations/cluster_preserve/cluster_preserve_quantize_registry.py

Pandinosaurus/model-optimization

12dc84dd34ee3c6eb08b381c0abcd65b31a42366

[ "Apache-2.0" ]

290

2019-05-14T17:42:49.000Z

2022-03-28T02:21:45.000Z

# Copyright 2021 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Registry responsible for built-in keras classes.""" import logging import tensorflow as tf from tensorflow_model_optimization.python.core.clustering.keras import clustering_registry from tensorflow_model_optimization.python.core.quantization.keras import quant_ops from tensorflow_model_optimization.python.core.quantization.keras import quantizers from tensorflow_model_optimization.python.core.quantization.keras.default_8bit import default_8bit_quantize_registry from tensorflow_model_optimization.python.core.quantization.keras.default_8bit import default_8bit_quantizers layers = tf.keras.layers K = tf.keras.backend CLUSTER_CENTROIDS = 'cluster_centroids_tf' PULLING_INDICES = 'pulling_indices_tf' ORIGINAL_WEIGHTS = 'ori_weights_vars_tf' WEIGHT_NAME = 'weight_name' CLUSTERING_IMPL = 'clst_impl' CENTROIDS_MASK = 'centroids_mask' SPARSITY_MASK = 'sparsity_mask' def get_unique(t): """Get unique values and lookup index from N-D tensor. Args: t: tensor Returns: unique value, lookup index (same shape as input tensor) Example: t: ([[1.0, 2.0], [2.0, 3.0], [3.0, 3.0], [1.0, 2.0]] ) uniques: ([1.0, 2.0, 3.0]) output final index: ([[0, 1], [1, 2], [2, 2], [0, 1]] ) """ t_flatten = tf.reshape(t, shape=(-1,)) uniques, index = tf.unique(t_flatten) return uniques, tf.reshape(index, shape=tf.shape(t)) class _ClusterPreserveInfo(object): """ClusterPreserveInfo.""" def __init__(self, weight_attrs, quantize_config_attrs): """ClusterPreserveInfo. Args: weight_attrs: list of cluster preservable weight attributes of layer. quantize_config_attrs: list of quantization configuration class name. """ self.weight_attrs = weight_attrs self.quantize_config_attrs = quantize_config_attrs class ClusterPreserveQuantizeRegistry(object): """ClusterPreserveQuantizeRegistry is for built-in keras layers.""" # The keys represent built-in keras layers; the first values represent the # the variables within the layers which hold the kernel weights, second # values represent the class name of quantization configuration for layers. # This decide the weights of layers with quantization configurations are # cluster preservable. _LAYERS_CONFIG_MAP = { layers.Conv2D: _ClusterPreserveInfo(['kernel'], ['Default8BitConvQuantizeConfig']), layers.Dense: _ClusterPreserveInfo(['kernel'], ['Default8BitQuantizeConfig']), # DepthwiseConv2D is supported with 8bit qat, but not with # clustering, thus for DepthwiseConv2D CQAT, # preserving clustered weights is disabled. layers.DepthwiseConv2D: _ClusterPreserveInfo(['depthwise_kernel'], ['Default8BitQuantizeConfig']), # layers that are supported with clustering, but not yet with qat # layers.Conv1D: # _ClusterPreserveInfo(['kernel'], []), # layers.Conv2DTranspose: # _ClusterPreserveInfo(['kernel'], []), # layers.Conv3D: # _ClusterPreserveInfo(['kernel'], []), # layers.Conv3DTranspose: # _ClusterPreserveInfo(['kernel'], []), # layers.LocallyConnected1D: # _ClusterPreserveInfo(['kernel'], ['Default8BitQuantizeConfig']), # layers.LocallyConnected2D: # _ClusterPreserveInfo(['kernel'], ['Default8BitQuantizeConfig']), # SeparableConv need verify from 8bit qat # layers.SeparableConv1D: # _ClusterPreserveInfo(['pointwise_kernel'], # ['Default8BitConvQuantizeConfig']), # layers.SeparableConv2D: # _ClusterPreserveInfo(['pointwise_kernel'], # ['Default8BitConvQuantizeConfig']), # Embedding need verify from 8bit qat # layers.Embedding: _ClusterPreserveInfo(['embeddings'], []), } _DISABLE_CLUSTER_PRESERVE = frozenset({ layers.DepthwiseConv2D, }) def __init__(self, preserve_sparsity): self._config_quantizer_map = { 'Default8BitQuantizeConfig': ClusterPreserveDefault8BitWeightsQuantizer(preserve_sparsity), 'Default8BitConvQuantizeConfig': ClusterPreserveDefault8BitConvWeightsQuantizer(preserve_sparsity), } @classmethod def _no_trainable_weights(cls, layer): """Returns whether this layer has trainable weights. Args: layer: The layer to check for trainable weights. Returns: True/False whether the layer has trainable weights. """ return not layer.trainable_weights @classmethod def _disable_cluster_preserve(cls, layer): """Returns whether to disable this layer for preserving clusters. Args: layer: The layer to check for disabling. Returns: True/False whether disabling this layer for preserving clusters. """ return layer.__class__ in cls._DISABLE_CLUSTER_PRESERVE @classmethod def supports(cls, layer): """Returns whether the registry supports this layer type. Args: layer: The layer to check for support. Returns: True/False whether the layer type is supported. """ # layers without trainable weights are consider supported, # e.g., ReLU, Softmax, and AveragePooling2D. if cls._no_trainable_weights(layer): return True if layer.__class__ in cls._LAYERS_CONFIG_MAP: return True return False @classmethod def _weight_names(cls, layer): if cls._no_trainable_weights(layer): return [] return cls._LAYERS_CONFIG_MAP[layer.__class__].weight_attrs def apply_cluster_preserve_quantize_config(self, layer, quantize_config): """Applies cluster-preserve weight quantizer. Args: layer: The layer to check for support. quantize_config: quantization config for supporting cluster preservation on clustered weights Returns: The quantize_config with addon cluster preserve weight_quantizer. """ if not self.supports(layer): raise ValueError('Layer ' + str(layer.__class__) + ' is not supported.') # Example: ReLU, Softmax, and AveragePooling2D (without trainable weights) # DepthwiseConv2D (cluster_preserve is disabled) if self._no_trainable_weights(layer) or self._disable_cluster_preserve( layer): return quantize_config # Example: Conv2D, Dense layers if quantize_config.__class__.__name__ in self._LAYERS_CONFIG_MAP[ layer.__class__].quantize_config_attrs: quantize_config.weight_quantizer = self._config_quantizer_map[ quantize_config.__class__.__name__] else: raise ValueError('Configuration ' + str(quantize_config.__class__.__name__) + ' is not supported for Layer ' + str(layer.__class__) + '.') return quantize_config class Default8bitClusterPreserveQuantizeRegistry( ClusterPreserveQuantizeRegistry): """Default 8 bit ClusterPreserveQuantizeRegistry.""" def __init__(self, preserve_sparsity): super(Default8bitClusterPreserveQuantizeRegistry, self).__init__( preserve_sparsity) self.preserve_sparsity = preserve_sparsity def get_quantize_config(self, layer): """Returns the quantization config with weight_quantizer for a given layer. Args: layer: input layer to return quantize config for. Returns: Returns the quantization config for cluster preserve weight_quantizer. """ quantize_config = (default_8bit_quantize_registry. Default8BitQuantizeRegistry(). get_quantize_config(layer)) cluster_aware_quantize_config = super( Default8bitClusterPreserveQuantizeRegistry, self).apply_cluster_preserve_quantize_config(layer, quantize_config) return cluster_aware_quantize_config class ClusterPreserveDefaultWeightsQuantizer(quantizers.LastValueQuantizer): """Quantize weights while preserving clusters.""" def __init__( self, num_bits, per_axis, symmetric, narrow_range, preserve_sparsity): """ClusterPreserveDefaultWeightsQuantizer. Args: num_bits: Number of bits for quantization per_axis: Whether to apply per_axis quantization. The last dimension is used as the axis. symmetric: If true, use symmetric quantization limits instead of training the minimum and maximum of each quantization range separately. narrow_range: In case of 8 bits, narrow_range nudges the quantized range to be [-127, 127] instead of [-128, 127]. This ensures symmetric range has 0 as the centre. preserve_sparsity: Whether to apply prune-cluster-preserving quantization aware training. """ super(ClusterPreserveDefaultWeightsQuantizer, self).__init__( num_bits=num_bits, per_axis=per_axis, symmetric=symmetric, narrow_range=narrow_range, ) self.preserve_sparsity = preserve_sparsity def _build_clusters(self, name, layer): """Extracts the cluster centroids and cluster indices. Extracts cluster centroids and cluster indices from the pretrained clustered model when the input layer is clustered. Args: name: Name of weights in layer. layer: Quantization wrapped keras layer. Returns: A dictionary of the initial values of the cluster centroids, cluster indices, original weights, the pretrained flag for marking the first training epoch, and weight name. """ result = {} weights = getattr(layer.layer, name) if self.preserve_sparsity and not tf.reduce_any(weights == 0): self.preserve_sparsity = False logging.warning( 'Input layer does not contain zero weights, so apply CQAT instead.') centroids_mask = None centroids, lookup = get_unique(weights) num_centroids = tf.size(centroids) if self.preserve_sparsity: sparsity_mask = tf.math.divide_no_nan(weights, weights) zero_idx = tf.argmin(tf.abs(centroids), axis=-1) centroids_mask = 1.0 - tf.one_hot(zero_idx, num_centroids) result = {SPARSITY_MASK: sparsity_mask} # Prepare clustering variables for the Keras graph when clusters # exist, assuming we do not use number_of_clusters larger than 1024 if num_centroids > 1024: return result else: clst_centroids_tf = layer.add_weight( CLUSTER_CENTROIDS, shape=centroids.shape, initializer=tf.keras.initializers.Constant( value=K.batch_get_value([centroids])[0]), dtype=centroids.dtype, trainable=True) ori_weights_tf = layer.add_weight( ORIGINAL_WEIGHTS, shape=weights.shape, initializer=tf.keras.initializers.Constant( value=K.batch_get_value([weights])[0]), dtype=weights.dtype, trainable=True) # Get clustering implementation according to layer type clustering_impl_cls = clustering_registry.ClusteringLookupRegistry( ).get_clustering_impl(layer.layer, name) clustering_impl = clustering_impl_cls(clst_centroids_tf) pulling_indices = tf.dtypes.cast( clustering_impl.get_pulling_indices(ori_weights_tf), lookup.dtype ) pulling_indices_tf = layer.add_weight( PULLING_INDICES, shape=lookup.shape, initializer=tf.keras.initializers.Constant( value=K.batch_get_value([pulling_indices])[0]), dtype=lookup.dtype, trainable=False) result_clst = { CLUSTER_CENTROIDS: clst_centroids_tf, PULLING_INDICES: pulling_indices_tf, ORIGINAL_WEIGHTS: ori_weights_tf, WEIGHT_NAME: name, CLUSTERING_IMPL: clustering_impl, CENTROIDS_MASK: centroids_mask, } result.update(result_clst) return result def build(self, tensor_shape, name, layer): """Build (P)CQAT wrapper. When preserve_sparsity is true and the input is clustered. Args: tensor_shape: Shape of weights which needs to be quantized. name: Name of weights in layer. layer: Quantization wrapped keras layer. Returns: Dictionary of centroids, indices and quantization params, the dictionary will be passed to __call__ function. """ # To get all the initial values from pretrained clustered model result = self._build_clusters(name, layer) # Result can have clustering nodes, then this is CQAT # Result can have both clustering nodes and sparsity mask, then # this will be PCQAT result.update( super(ClusterPreserveDefaultWeightsQuantizer, self).build(tensor_shape, name, layer)) return result def __call__(self, inputs, training, weights, **kwargs): """Apply cluster preserved quantization to the input tensor. Args: inputs: Input tensor (layer's weights) to be quantized. training: Whether the graph is currently training. weights: Dictionary of weights (params) the quantizer can use to quantize the tensor (layer's weights). This contains the weights created in the `build` function. **kwargs: Additional variables which may be passed to the quantizer. Returns: quantized tensor. """ if training: if CLUSTER_CENTROIDS in weights: if self.preserve_sparsity: weights[ORIGINAL_WEIGHTS].assign( tf.multiply(weights[ORIGINAL_WEIGHTS], weights[SPARSITY_MASK])) weights[CLUSTERING_IMPL].cluster_centroids.assign( weights[CLUSTERING_IMPL]. cluster_centroids * weights[CENTROIDS_MASK] ) weights[CLUSTER_CENTROIDS].assign( weights[CLUSTERING_IMPL].cluster_centroids ) # Insert clustering variables weights[PULLING_INDICES].assign(tf.dtypes.cast( weights[CLUSTERING_IMPL].get_pulling_indices( weights[ORIGINAL_WEIGHTS]), weights[PULLING_INDICES].dtype )) output = weights[CLUSTERING_IMPL].get_clustered_weight( weights[PULLING_INDICES], weights[ORIGINAL_WEIGHTS]) inputs.assign(output) else: if self.preserve_sparsity: inputs = tf.multiply(inputs, weights[SPARSITY_MASK]) output = inputs else: output = inputs return quant_ops.LastValueQuantize( output, weights['min_var'], weights['max_var'], is_training=training, num_bits=self.num_bits, per_channel=self.per_axis, symmetric=self.symmetric, narrow_range=self.narrow_range ) class ClusterPreserveDefault8BitWeightsQuantizer( ClusterPreserveDefaultWeightsQuantizer): """ClusterPreserveWeightsQuantizer for default 8bit weights.""" def __init__(self, preserve_sparsity): super(ClusterPreserveDefault8BitWeightsQuantizer, self).__init__(num_bits=8, per_axis=False, symmetric=True, narrow_range=True, preserve_sparsity=preserve_sparsity) self.preserve_sparsity = preserve_sparsity class ClusterPreserveDefault8BitConvWeightsQuantizer( ClusterPreserveDefaultWeightsQuantizer, default_8bit_quantizers.Default8BitConvWeightsQuantizer): """ClusterPreserveWeightsQuantizer for default 8bit Conv2D weights.""" def __init__(self, preserve_sparsity): # pylint: disable=super-init-not-called default_8bit_quantizers.Default8BitConvWeightsQuantizer.__init__(self) self.preserve_sparsity = preserve_sparsity def build(self, tensor_shape, name, layer): result = ClusterPreserveDefaultWeightsQuantizer._build_clusters( self, name, layer) result.update( default_8bit_quantizers.Default8BitConvWeightsQuantizer.build( self, tensor_shape, name, layer)) return result

35.760776

116

0.695474

import logging import tensorflow as tf from tensorflow_model_optimization.python.core.clustering.keras import clustering_registry from tensorflow_model_optimization.python.core.quantization.keras import quant_ops from tensorflow_model_optimization.python.core.quantization.keras import quantizers from tensorflow_model_optimization.python.core.quantization.keras.default_8bit import default_8bit_quantize_registry from tensorflow_model_optimization.python.core.quantization.keras.default_8bit import default_8bit_quantizers layers = tf.keras.layers K = tf.keras.backend CLUSTER_CENTROIDS = 'cluster_centroids_tf' PULLING_INDICES = 'pulling_indices_tf' ORIGINAL_WEIGHTS = 'ori_weights_vars_tf' WEIGHT_NAME = 'weight_name' CLUSTERING_IMPL = 'clst_impl' CENTROIDS_MASK = 'centroids_mask' SPARSITY_MASK = 'sparsity_mask' def get_unique(t): t_flatten = tf.reshape(t, shape=(-1,)) uniques, index = tf.unique(t_flatten) return uniques, tf.reshape(index, shape=tf.shape(t)) class _ClusterPreserveInfo(object): def __init__(self, weight_attrs, quantize_config_attrs): self.weight_attrs = weight_attrs self.quantize_config_attrs = quantize_config_attrs class ClusterPreserveQuantizeRegistry(object): _LAYERS_CONFIG_MAP = { layers.Conv2D: _ClusterPreserveInfo(['kernel'], ['Default8BitConvQuantizeConfig']), layers.Dense: _ClusterPreserveInfo(['kernel'], ['Default8BitQuantizeConfig']), layers.DepthwiseConv2D: _ClusterPreserveInfo(['depthwise_kernel'], ['Default8BitQuantizeConfig']), } _DISABLE_CLUSTER_PRESERVE = frozenset({ layers.DepthwiseConv2D, }) def __init__(self, preserve_sparsity): self._config_quantizer_map = { 'Default8BitQuantizeConfig': ClusterPreserveDefault8BitWeightsQuantizer(preserve_sparsity), 'Default8BitConvQuantizeConfig': ClusterPreserveDefault8BitConvWeightsQuantizer(preserve_sparsity), } @classmethod def _no_trainable_weights(cls, layer): return not layer.trainable_weights @classmethod def _disable_cluster_preserve(cls, layer): return layer.__class__ in cls._DISABLE_CLUSTER_PRESERVE @classmethod def supports(cls, layer): if cls._no_trainable_weights(layer): return True if layer.__class__ in cls._LAYERS_CONFIG_MAP: return True return False @classmethod def _weight_names(cls, layer): if cls._no_trainable_weights(layer): return [] return cls._LAYERS_CONFIG_MAP[layer.__class__].weight_attrs def apply_cluster_preserve_quantize_config(self, layer, quantize_config): if not self.supports(layer): raise ValueError('Layer ' + str(layer.__class__) + ' is not supported.') if self._no_trainable_weights(layer) or self._disable_cluster_preserve( layer): return quantize_config if quantize_config.__class__.__name__ in self._LAYERS_CONFIG_MAP[ layer.__class__].quantize_config_attrs: quantize_config.weight_quantizer = self._config_quantizer_map[ quantize_config.__class__.__name__] else: raise ValueError('Configuration ' + str(quantize_config.__class__.__name__) + ' is not supported for Layer ' + str(layer.__class__) + '.') return quantize_config class Default8bitClusterPreserveQuantizeRegistry( ClusterPreserveQuantizeRegistry): def __init__(self, preserve_sparsity): super(Default8bitClusterPreserveQuantizeRegistry, self).__init__( preserve_sparsity) self.preserve_sparsity = preserve_sparsity def get_quantize_config(self, layer): quantize_config = (default_8bit_quantize_registry. Default8BitQuantizeRegistry(). get_quantize_config(layer)) cluster_aware_quantize_config = super( Default8bitClusterPreserveQuantizeRegistry, self).apply_cluster_preserve_quantize_config(layer, quantize_config) return cluster_aware_quantize_config class ClusterPreserveDefaultWeightsQuantizer(quantizers.LastValueQuantizer): def __init__( self, num_bits, per_axis, symmetric, narrow_range, preserve_sparsity): super(ClusterPreserveDefaultWeightsQuantizer, self).__init__( num_bits=num_bits, per_axis=per_axis, symmetric=symmetric, narrow_range=narrow_range, ) self.preserve_sparsity = preserve_sparsity def _build_clusters(self, name, layer): result = {} weights = getattr(layer.layer, name) if self.preserve_sparsity and not tf.reduce_any(weights == 0): self.preserve_sparsity = False logging.warning( 'Input layer does not contain zero weights, so apply CQAT instead.') centroids_mask = None centroids, lookup = get_unique(weights) num_centroids = tf.size(centroids) if self.preserve_sparsity: sparsity_mask = tf.math.divide_no_nan(weights, weights) zero_idx = tf.argmin(tf.abs(centroids), axis=-1) centroids_mask = 1.0 - tf.one_hot(zero_idx, num_centroids) result = {SPARSITY_MASK: sparsity_mask} if num_centroids > 1024: return result else: clst_centroids_tf = layer.add_weight( CLUSTER_CENTROIDS, shape=centroids.shape, initializer=tf.keras.initializers.Constant( value=K.batch_get_value([centroids])[0]), dtype=centroids.dtype, trainable=True) ori_weights_tf = layer.add_weight( ORIGINAL_WEIGHTS, shape=weights.shape, initializer=tf.keras.initializers.Constant( value=K.batch_get_value([weights])[0]), dtype=weights.dtype, trainable=True) clustering_impl_cls = clustering_registry.ClusteringLookupRegistry( ).get_clustering_impl(layer.layer, name) clustering_impl = clustering_impl_cls(clst_centroids_tf) pulling_indices = tf.dtypes.cast( clustering_impl.get_pulling_indices(ori_weights_tf), lookup.dtype ) pulling_indices_tf = layer.add_weight( PULLING_INDICES, shape=lookup.shape, initializer=tf.keras.initializers.Constant( value=K.batch_get_value([pulling_indices])[0]), dtype=lookup.dtype, trainable=False) result_clst = { CLUSTER_CENTROIDS: clst_centroids_tf, PULLING_INDICES: pulling_indices_tf, ORIGINAL_WEIGHTS: ori_weights_tf, WEIGHT_NAME: name, CLUSTERING_IMPL: clustering_impl, CENTROIDS_MASK: centroids_mask, } result.update(result_clst) return result def build(self, tensor_shape, name, layer): result = self._build_clusters(name, layer) result.update( super(ClusterPreserveDefaultWeightsQuantizer, self).build(tensor_shape, name, layer)) return result def __call__(self, inputs, training, weights, **kwargs): if training: if CLUSTER_CENTROIDS in weights: if self.preserve_sparsity: weights[ORIGINAL_WEIGHTS].assign( tf.multiply(weights[ORIGINAL_WEIGHTS], weights[SPARSITY_MASK])) weights[CLUSTERING_IMPL].cluster_centroids.assign( weights[CLUSTERING_IMPL]. cluster_centroids * weights[CENTROIDS_MASK] ) weights[CLUSTER_CENTROIDS].assign( weights[CLUSTERING_IMPL].cluster_centroids ) weights[PULLING_INDICES].assign(tf.dtypes.cast( weights[CLUSTERING_IMPL].get_pulling_indices( weights[ORIGINAL_WEIGHTS]), weights[PULLING_INDICES].dtype )) output = weights[CLUSTERING_IMPL].get_clustered_weight( weights[PULLING_INDICES], weights[ORIGINAL_WEIGHTS]) inputs.assign(output) else: if self.preserve_sparsity: inputs = tf.multiply(inputs, weights[SPARSITY_MASK]) output = inputs else: output = inputs return quant_ops.LastValueQuantize( output, weights['min_var'], weights['max_var'], is_training=training, num_bits=self.num_bits, per_channel=self.per_axis, symmetric=self.symmetric, narrow_range=self.narrow_range ) class ClusterPreserveDefault8BitWeightsQuantizer( ClusterPreserveDefaultWeightsQuantizer): def __init__(self, preserve_sparsity): super(ClusterPreserveDefault8BitWeightsQuantizer, self).__init__(num_bits=8, per_axis=False, symmetric=True, narrow_range=True, preserve_sparsity=preserve_sparsity) self.preserve_sparsity = preserve_sparsity class ClusterPreserveDefault8BitConvWeightsQuantizer( ClusterPreserveDefaultWeightsQuantizer, default_8bit_quantizers.Default8BitConvWeightsQuantizer): def __init__(self, preserve_sparsity): default_8bit_quantizers.Default8BitConvWeightsQuantizer.__init__(self) self.preserve_sparsity = preserve_sparsity def build(self, tensor_shape, name, layer): result = ClusterPreserveDefaultWeightsQuantizer._build_clusters( self, name, layer) result.update( default_8bit_quantizers.Default8BitConvWeightsQuantizer.build( self, tensor_shape, name, layer)) return result

true

f71322a81de8147a42afd098b9ff1f141e46acd6

2,152

py

Python

src/scs_psu/batt_pack/batt_pack_v1.py

south-coast-science/scs_psu

d8d5bf5b31833b33ae7d2aca268285f3cc2c6e62

[ "MIT" ]

null

src/scs_psu/batt_pack/batt_pack_v1.py

south-coast-science/scs_psu

d8d5bf5b31833b33ae7d2aca268285f3cc2c6e62

[ "MIT" ]

null

src/scs_psu/batt_pack/batt_pack_v1.py

south-coast-science/scs_psu

d8d5bf5b31833b33ae7d2aca268285f3cc2c6e62

[ "MIT" ]

1

2017-12-05T12:40:54.000Z

""" Created on 3 Oct 2019 @author: Bruno Beloff (bruno.beloff@southcoastscience.com) Used by version 1 Handhelds. Tuned for 2 x Nitecore IMR 18650 (3.7 V, 3100 mAh) https://www.nitecore.co.uk/Shop/Products/Batteries/13663-Nitecore-IMR-18650-Battery-for-TM28-Torch.html#Features """ import json from scs_psu.batt_pack.batt_pack import BattPack from scs_psu.batt_pack.fuel_gauge.max17055.max17055_config import Max17055Config from scs_psu.batt_pack.fuel_gauge.max17055.max17055_params import Max17055Params # -------------------------------------------------------------------------------------------------------------------- class BattPackV1(BattPack): """ classdocs """ __CHARGE_MINIMUM = 1 # percent __DEFAULT_PARAMS = '{"calibrated-on": "2021-04-19T13:29:46+01:00", "r-comp-0": 106, "temp-co": 8766, ' \ '"full-cap-rep": 10396, "full-cap-nom": 40738, "cycles": 245}' # ---------------------------------------------------------------------------------------------------------------- @staticmethod def name(): return 'PackV1' @staticmethod def gauge_conf(): des_cap = 6200 # mAh sense_res = 0.01 # Ω chrg_term = 10 # mA empty_v_target = 3.3 # V recovery_v = 3.8 # V chrg_v = Max17055Config.CHRG_V_4_2 batt_type = Max17055Config.BATT_TYPE_LiCoO2 return Max17055Config(des_cap, sense_res, chrg_term, empty_v_target, recovery_v, chrg_v, batt_type) # ---------------------------------------------------------------------------------------------------------------- @classmethod def charge_min(cls): return cls.__CHARGE_MINIMUM @classmethod def default_params(cls): return Max17055Params.construct_from_jdict(json.loads(cls.__DEFAULT_PARAMS)) # ---------------------------------------------------------------------------------------------------------------- def __init__(self, gauge): """ Constructor """ super().__init__(gauge)

29.479452

118

0.490706

import json from scs_psu.batt_pack.batt_pack import BattPack from scs_psu.batt_pack.fuel_gauge.max17055.max17055_config import Max17055Config from scs_psu.batt_pack.fuel_gauge.max17055.max17055_params import Max17055Params class BattPackV1(BattPack): __CHARGE_MINIMUM = 1 __DEFAULT_PARAMS = '{"calibrated-on": "2021-04-19T13:29:46+01:00", "r-comp-0": 106, "temp-co": 8766, ' \ '"full-cap-rep": 10396, "full-cap-nom": 40738, "cycles": 245}' @staticmethod def name(): return 'PackV1' @staticmethod def gauge_conf(): des_cap = 6200 sense_res = 0.01 chrg_term = 10 empty_v_target = 3.3 recovery_v = 3.8 chrg_v = Max17055Config.CHRG_V_4_2 batt_type = Max17055Config.BATT_TYPE_LiCoO2 return Max17055Config(des_cap, sense_res, chrg_term, empty_v_target, recovery_v, chrg_v, batt_type) @classmethod def charge_min(cls): return cls.__CHARGE_MINIMUM @classmethod def default_params(cls): return Max17055Params.construct_from_jdict(json.loads(cls.__DEFAULT_PARAMS)) def __init__(self, gauge): super().__init__(gauge)

true

f71322b77a9edd885d7cb35ba9a4009a8a226f25

960

py

Python

Playground3/src/playground/network/packet/encoders/PlaygroundFramingPacketEncoder.py

kandarpck/networksecurity2018

dafe2ee8d39bd9596b1ce3fbc8b50ca645bcd626

[ "MIT" ]

3

2018-10-25T16:03:53.000Z

2019-06-13T15:24:41.000Z

Playground3/src/playground/network/packet/encoders/PlaygroundFramingPacketEncoder.py

kandarpck/networksecurity2018

dafe2ee8d39bd9596b1ce3fbc8b50ca645bcd626

[ "MIT" ]

null

Playground3/src/playground/network/packet/encoders/PlaygroundFramingPacketEncoder.py

kandarpck/networksecurity2018

dafe2ee8d39bd9596b1ce3fbc8b50ca645bcd626

[ "MIT" ]

null

''' Created on Oct 11, 2017 @author: seth_ ''' from .PlaygroundStandardPacketEncoder import PlaygroundStandardPacketEncoder, PacketEncoder from .PacketFramingStream import PacketFramingStreamAdapter class PlaygroundFramingPacketEncoder(PlaygroundStandardPacketEncoder): def encode(self, stream, fieldType): typeEncoder = self.GetTypeEncoder(fieldType) if typeEncoder == PacketEncoder: stream = PacketFramingStreamAdapter.Adapt(stream) ret = super().encode(stream, fieldType) if typeEncoder == PacketEncoder: stream.writeFrame() def decodeIterator(self, stream, fieldType): typeEncoder = self.GetTypeEncoder(fieldType) if typeEncoder == PacketEncoder: stream = PacketFramingStreamAdapter.Adapt(stream) yield from super().decodeIterator(stream, fieldType) if typeEncoder == PacketEncoder: stream.closeFrame()

40

92

0.696875

from .PlaygroundStandardPacketEncoder import PlaygroundStandardPacketEncoder, PacketEncoder from .PacketFramingStream import PacketFramingStreamAdapter class PlaygroundFramingPacketEncoder(PlaygroundStandardPacketEncoder): def encode(self, stream, fieldType): typeEncoder = self.GetTypeEncoder(fieldType) if typeEncoder == PacketEncoder: stream = PacketFramingStreamAdapter.Adapt(stream) ret = super().encode(stream, fieldType) if typeEncoder == PacketEncoder: stream.writeFrame() def decodeIterator(self, stream, fieldType): typeEncoder = self.GetTypeEncoder(fieldType) if typeEncoder == PacketEncoder: stream = PacketFramingStreamAdapter.Adapt(stream) yield from super().decodeIterator(stream, fieldType) if typeEncoder == PacketEncoder: stream.closeFrame()

true

f71322f749c42287b9d7de83530abd932b395670

10,558

py

Python

zerver/tornado/handlers.py

myii/zulip

915d8013271f1823954dd8d4441842842857ab9f

[ "Apache-2.0" ]

1

2020-03-19T00:52:48.000Z

zerver/tornado/handlers.py

myii/zulip

915d8013271f1823954dd8d4441842842857ab9f

[ "Apache-2.0" ]

null

zerver/tornado/handlers.py

myii/zulip

915d8013271f1823954dd8d4441842842857ab9f

[ "Apache-2.0" ]

1

2020-04-21T01:26:54.000Z

import logging import urllib from typing import Any, Dict, List import tornado.web from django import http from django.core import signals from django.core.handlers import base from django.core.handlers.wsgi import WSGIRequest, get_script_name from django.urls import set_script_prefix from django.http import HttpRequest, HttpResponse from tornado.wsgi import WSGIContainer from zerver.lib.response import json_response from zerver.middleware import async_request_timer_restart, async_request_timer_stop from zerver.tornado.descriptors import get_descriptor_by_handler_id current_handler_id = 0 handlers: Dict[int, 'AsyncDjangoHandler'] = {} # Copied from django.core.handlers.base logger = logging.getLogger('django.request') def get_handler_by_id(handler_id: int) -> 'AsyncDjangoHandler': return handlers[handler_id] def allocate_handler_id(handler: 'AsyncDjangoHandler') -> int: global current_handler_id handlers[current_handler_id] = handler handler.handler_id = current_handler_id current_handler_id += 1 return handler.handler_id def clear_handler_by_id(handler_id: int) -> None: del handlers[handler_id] def handler_stats_string() -> str: return "%s handlers, latest ID %s" % (len(handlers), current_handler_id) def finish_handler(handler_id: int, event_queue_id: str, contents: List[Dict[str, Any]], apply_markdown: bool) -> None: err_msg = "Got error finishing handler for queue %s" % (event_queue_id,) try: # We call async_request_timer_restart here in case we are # being finished without any events (because another # get_events request has supplanted this request) handler = get_handler_by_id(handler_id) request = handler._request async_request_timer_restart(request) if len(contents) != 1: request._log_data['extra'] = "[%s/1]" % (event_queue_id,) else: request._log_data['extra'] = "[%s/1/%s]" % (event_queue_id, contents[0]["type"]) handler.zulip_finish(dict(result='success', msg='', events=contents, queue_id=event_queue_id), request, apply_markdown=apply_markdown) except OSError as e: if str(e) != 'Stream is closed': logging.exception(err_msg) except AssertionError as e: if str(e) != 'Request closed': logging.exception(err_msg) except Exception: logging.exception(err_msg) class AsyncDjangoHandler(tornado.web.RequestHandler, base.BaseHandler): def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) # Copied from the django.core.handlers.wsgi __init__() method. self.load_middleware() # Prevent Tornado from automatically finishing the request self._auto_finish = False # Handler IDs are allocated here, and the handler ID map must # be cleared when the handler finishes its response allocate_handler_id(self) def __repr__(self) -> str: descriptor = get_descriptor_by_handler_id(self.handler_id) return "AsyncDjangoHandler<%s, %s>" % (self.handler_id, descriptor) def convert_tornado_request_to_django_request(self) -> HttpRequest: # This takes the WSGI environment that Tornado received (which # fully describes the HTTP request that was sent to Tornado) # and pass it to Django's WSGIRequest to generate a Django # HttpRequest object with the original Tornado request's HTTP # headers, parameters, etc. environ = WSGIContainer.environ(self.request) environ['PATH_INFO'] = urllib.parse.unquote(environ['PATH_INFO']) # Django WSGIRequest setup code that should match logic from # Django's WSGIHandler.__call__ before the call to # `get_response()`. set_script_prefix(get_script_name(environ)) signals.request_started.send(sender=self.__class__) request = WSGIRequest(environ) # Provide a way for application code to access this handler # given the HttpRequest object. request._tornado_handler = self return request def write_django_response_as_tornado_response(self, response: HttpResponse) -> None: # This takes a Django HttpResponse and copies its HTTP status # code, headers, cookies, and content onto this # tornado.web.RequestHandler (which is how Tornado prepares a # response to write). # Copy the HTTP status code. self.set_status(response.status_code) # Copy the HTTP headers (iterating through a Django # HttpResponse is the way to access its headers as key/value pairs) for h in response.items(): self.set_header(h[0], h[1]) # Copy any cookies if not hasattr(self, "_new_cookies"): self._new_cookies: List[http.cookie.SimpleCookie[str]] = [] self._new_cookies.append(response.cookies) # Copy the response content self.write(response.content) # Close the connection. self.finish() def get(self, *args: Any, **kwargs: Any) -> None: request = self.convert_tornado_request_to_django_request() try: response = self.get_response(request) if hasattr(response, "asynchronous"): # For asynchronous requests, this is where we exit # without returning the HttpResponse that Django # generated back to the user in order to long-poll the # connection. We save some timers here in order to # support accurate accounting of the total resources # consumed by the request when it eventually returns a # response and is logged. async_request_timer_stop(request) return finally: # Tell Django that we're done processing this request on # the Django side; this triggers cleanup work like # resetting the urlconf and any cache/database # connections. signals.request_finished.send(sender=self.__class__) # For normal/synchronous requests that don't end up # long-polling, we fall through to here and just need to write # the HTTP response that Django prepared for us via Tornado. # Mark this handler ID as finished for Zulip's own tracking. clear_handler_by_id(self.handler_id) self.write_django_response_as_tornado_response(response) def head(self, *args: Any, **kwargs: Any) -> None: self.get(*args, **kwargs) def post(self, *args: Any, **kwargs: Any) -> None: self.get(*args, **kwargs) def delete(self, *args: Any, **kwargs: Any) -> None: self.get(*args, **kwargs) def on_connection_close(self) -> None: # Register a Tornado handler that runs when client-side # connections are closed to notify the events system. # # TODO: Theoretically, this code should run when you Ctrl-C # curl to cause it to break a `GET /events` connection, but # that seems to no longer run this code. Investigate what's up. client_descriptor = get_descriptor_by_handler_id(self.handler_id) if client_descriptor is not None: client_descriptor.disconnect_handler(client_closed=True) def zulip_finish(self, result_dict: Dict[str, Any], old_request: HttpRequest, apply_markdown: bool) -> None: # Function called when we want to break a long-polled # get_events request and return a response to the client. # Marshall the response data from result_dict. if result_dict['result'] == 'success' and 'messages' in result_dict and apply_markdown: for msg in result_dict['messages']: if msg['content_type'] != 'text/html': self.set_status(500) self.finish('Internal error: bad message format') if result_dict['result'] == 'error': self.set_status(400) # The `result` dictionary contains the data we want to return # to the client. We want to do so in a proper Tornado HTTP # response after running the Django response middleware (which # does things like log the request, add rate-limit headers, # etc.). The Django middleware API expects to receive a fresh # HttpRequest object, and so to minimize hacks, our strategy # is to create a duplicate Django HttpRequest object, tagged # to automatically return our data in its response, and call # Django's main self.get_response() handler to generate an # HttpResponse with all Django middleware run. request = self.convert_tornado_request_to_django_request() # Add to this new HttpRequest logging data from the processing of # the original request; we will need these for logging. # # TODO: Design a cleaner way to manage these attributes, # perhaps via creating a ZulipHttpRequest class that contains # these attributes with a copy method. request._log_data = old_request._log_data if hasattr(request, "_rate_limit"): request._rate_limit = old_request._rate_limit if hasattr(request, "_requestor_for_logs"): request._requestor_for_logs = old_request._requestor_for_logs request.user = old_request.user request.client = old_request.client # The saved_response attribute, if present, causes # rest_dispatch to return the response immediately before # doing any work. This arrangement allows Django's full # request/middleware system to run unmodified while avoiding # running expensive things like Zulip's authentication code a # second time. request.saved_response = json_response(res_type=result_dict['result'], data=result_dict, status=self.get_status()) try: response = self.get_response(request) finally: # Tell Django we're done processing this request # # TODO: Investigate whether this (and other call points in # this file) should be using response.close() instead. signals.request_finished.send(sender=self.__class__) self.write_django_response_as_tornado_response(response)

43.093878

95

0.664709

import logging import urllib from typing import Any, Dict, List import tornado.web from django import http from django.core import signals from django.core.handlers import base from django.core.handlers.wsgi import WSGIRequest, get_script_name from django.urls import set_script_prefix from django.http import HttpRequest, HttpResponse from tornado.wsgi import WSGIContainer from zerver.lib.response import json_response from zerver.middleware import async_request_timer_restart, async_request_timer_stop from zerver.tornado.descriptors import get_descriptor_by_handler_id current_handler_id = 0 handlers: Dict[int, 'AsyncDjangoHandler'] = {} logger = logging.getLogger('django.request') def get_handler_by_id(handler_id: int) -> 'AsyncDjangoHandler': return handlers[handler_id] def allocate_handler_id(handler: 'AsyncDjangoHandler') -> int: global current_handler_id handlers[current_handler_id] = handler handler.handler_id = current_handler_id current_handler_id += 1 return handler.handler_id def clear_handler_by_id(handler_id: int) -> None: del handlers[handler_id] def handler_stats_string() -> str: return "%s handlers, latest ID %s" % (len(handlers), current_handler_id) def finish_handler(handler_id: int, event_queue_id: str, contents: List[Dict[str, Any]], apply_markdown: bool) -> None: err_msg = "Got error finishing handler for queue %s" % (event_queue_id,) try: handler = get_handler_by_id(handler_id) request = handler._request async_request_timer_restart(request) if len(contents) != 1: request._log_data['extra'] = "[%s/1]" % (event_queue_id,) else: request._log_data['extra'] = "[%s/1/%s]" % (event_queue_id, contents[0]["type"]) handler.zulip_finish(dict(result='success', msg='', events=contents, queue_id=event_queue_id), request, apply_markdown=apply_markdown) except OSError as e: if str(e) != 'Stream is closed': logging.exception(err_msg) except AssertionError as e: if str(e) != 'Request closed': logging.exception(err_msg) except Exception: logging.exception(err_msg) class AsyncDjangoHandler(tornado.web.RequestHandler, base.BaseHandler): def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) self.load_middleware() self._auto_finish = False allocate_handler_id(self) def __repr__(self) -> str: descriptor = get_descriptor_by_handler_id(self.handler_id) return "AsyncDjangoHandler<%s, %s>" % (self.handler_id, descriptor) def convert_tornado_request_to_django_request(self) -> HttpRequest: # HttpRequest object with the original Tornado request's HTTP environ = WSGIContainer.environ(self.request) environ['PATH_INFO'] = urllib.parse.unquote(environ['PATH_INFO']) # `get_response()`. set_script_prefix(get_script_name(environ)) signals.request_started.send(sender=self.__class__) request = WSGIRequest(environ) # Provide a way for application code to access this handler # given the HttpRequest object. request._tornado_handler = self return request def write_django_response_as_tornado_response(self, response: HttpResponse) -> None: # This takes a Django HttpResponse and copies its HTTP status # code, headers, cookies, and content onto this # tornado.web.RequestHandler (which is how Tornado prepares a # response to write). # Copy the HTTP status code. self.set_status(response.status_code) # Copy the HTTP headers (iterating through a Django # HttpResponse is the way to access its headers as key/value pairs) for h in response.items(): self.set_header(h[0], h[1]) # Copy any cookies if not hasattr(self, "_new_cookies"): self._new_cookies: List[http.cookie.SimpleCookie[str]] = [] self._new_cookies.append(response.cookies) # Copy the response content self.write(response.content) # Close the connection. self.finish() def get(self, *args: Any, **kwargs: Any) -> None: request = self.convert_tornado_request_to_django_request() try: response = self.get_response(request) if hasattr(response, "asynchronous"): # For asynchronous requests, this is where we exit # without returning the HttpResponse that Django # generated back to the user in order to long-poll the # connection. We save some timers here in order to # support accurate accounting of the total resources # consumed by the request when it eventually returns a # response and is logged. async_request_timer_stop(request) return finally: # Tell Django that we're done processing this request on signals.request_finished.send(sender=self.__class__) # long-polling, we fall through to here and just need to write # the HTTP response that Django prepared for us via Tornado. # Mark this handler ID as finished for Zulip's own tracking. clear_handler_by_id(self.handler_id) self.write_django_response_as_tornado_response(response) def head(self, *args: Any, **kwargs: Any) -> None: self.get(*args, **kwargs) def post(self, *args: Any, **kwargs: Any) -> None: self.get(*args, **kwargs) def delete(self, *args: Any, **kwargs: Any) -> None: self.get(*args, **kwargs) def on_connection_close(self) -> None: client_descriptor = get_descriptor_by_handler_id(self.handler_id) if client_descriptor is not None: client_descriptor.disconnect_handler(client_closed=True) def zulip_finish(self, result_dict: Dict[str, Any], old_request: HttpRequest, apply_markdown: bool) -> None: # Function called when we want to break a long-polled # get_events request and return a response to the client. # Marshall the response data from result_dict. if result_dict['result'] == 'success' and 'messages' in result_dict and apply_markdown: for msg in result_dict['messages']: if msg['content_type'] != 'text/html': self.set_status(500) self.finish('Internal error: bad message format') if result_dict['result'] == 'error': self.set_status(400) # The `result` dictionary contains the data we want to return # to the client. We want to do so in a proper Tornado HTTP # response after running the Django response middleware (which # does things like log the request, add rate-limit headers, # etc.). The Django middleware API expects to receive a fresh # HttpRequest object, and so to minimize hacks, our strategy # is to create a duplicate Django HttpRequest object, tagged # to automatically return our data in its response, and call # Django's main self.get_response() handler to generate an request = self.convert_tornado_request_to_django_request() request._log_data = old_request._log_data if hasattr(request, "_rate_limit"): request._rate_limit = old_request._rate_limit if hasattr(request, "_requestor_for_logs"): request._requestor_for_logs = old_request._requestor_for_logs request.user = old_request.user request.client = old_request.client # request/middleware system to run unmodified while avoiding # running expensive things like Zulip's authentication code a request.saved_response = json_response(res_type=result_dict['result'], data=result_dict, status=self.get_status()) try: response = self.get_response(request) finally: # # TODO: Investigate whether this (and other call points in # this file) should be using response.close() instead. signals.request_finished.send(sender=self.__class__) self.write_django_response_as_tornado_response(response)

true

f713234cf5323ddeca5b16c10a9bfe6c3782f073

627

py

Python

backend/manage.py

crowdbotics-dev/adv-1-2

7aea5a8846c4b0ae9e6ba70313cb71a9df7b929f

[ "FTL", "AML", "RSA-MD" ]

null

backend/manage.py

crowdbotics-dev/adv-1-2

7aea5a8846c4b0ae9e6ba70313cb71a9df7b929f

[ "FTL", "AML", "RSA-MD" ]

null

backend/manage.py

crowdbotics-dev/adv-1-2

7aea5a8846c4b0ae9e6ba70313cb71a9df7b929f

[ "FTL", "AML", "RSA-MD" ]

null

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

28.5

73

0.682616

import os import sys def main(): os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'adv_1_2.settings') try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?" ) from exc execute_from_command_line(sys.argv) if __name__ == '__main__': main()

true

f713239c29f8472c0247eb27dc414179f318fc7c

2,259

py

Python

examples/batchMode/runBatchK6.py

lammySup/ncscli

1758b7c894f2b890c7462d63a9c46ce47bf1262b

[ "MIT" ]

null

examples/batchMode/runBatchK6.py

lammySup/ncscli

1758b7c894f2b890c7462d63a9c46ce47bf1262b

[ "MIT" ]

null

examples/batchMode/runBatchK6.py

lammySup/ncscli

1758b7c894f2b890c7462d63a9c46ce47bf1262b

[ "MIT" ]

null

#!/usr/bin/env python3 import datetime import logging import os import subprocess import sys import ncscli.batchRunner as batchRunner class k6FrameProcessor(batchRunner.frameProcessor): '''defines details for using k6 for a simplistic load test''' def installerCmd( self ): return 'tar -vzxf k6Worker/k6.tar.gz; ls -al k6Worker' def frameOutFileName( self, frameNum ): return 'worker_%03d.*' % frameNum #return 'worker_%03d.csv' % frameNum def frameCmd( self, frameNum ): cmd = 'cd k6Worker && ./k6 run -q script.js --out csv=~/worker_%03d.csv' % ( frameNum ) return cmd # configure logger formatting #logging.basicConfig() logger = logging.getLogger(__name__) logFmt = '%(asctime)s %(levelname)s %(module)s %(funcName)s %(message)s' logDateFmt = '%Y/%m/%d %H:%M:%S' formatter = logging.Formatter(fmt=logFmt, datefmt=logDateFmt ) logging.basicConfig(format=logFmt, datefmt=logDateFmt) #batchRunner.logger.setLevel(logging.DEBUG) # for more verbosity dateTimeTag = datetime.datetime.now().strftime( '%Y-%m-%d_%H%M%S' ) outDataDir = 'data/k6_' + dateTimeTag if not os.path.isfile( 'k6Worker/k6.tar.gz' ): logger.error( 'the compressed k6 binary was not found, you may need to build and compress it' ) sys.exit( 1) try: rc = batchRunner.runBatch( frameProcessor = k6FrameProcessor(), commonInFilePath = 'k6Worker', authToken = os.getenv('NCS_AUTH_TOKEN') or 'YourAuthTokenHere', encryptFiles=False, timeLimit = 80*60, instTimeLimit = 7*60, frameTimeLimit = 14*60, filter = '{"dpr": ">=48","ram:":">=2800000000","app-version": ">=2.1.11"}', outDataDir = outDataDir, startFrame = 1, endFrame = 6, nWorkers = 10, limitOneFramePerWorker = True, autoscaleMax = 2 ) if os.path.isfile( outDataDir +'/recruitLaunched.json' ): rc2 = subprocess.call( [sys.executable, 'plotK6Output.py', '--dataDirPath', outDataDir], stdout=subprocess.DEVNULL ) if rc2: logger.warning( 'plotK6Output.py exited with returnCode %d', rc2 ) sys.exit( rc ) except KeyboardInterrupt: logger.warning( 'an interuption occurred')

32.73913

99

0.653829

import datetime import logging import os import subprocess import sys import ncscli.batchRunner as batchRunner class k6FrameProcessor(batchRunner.frameProcessor): def installerCmd( self ): return 'tar -vzxf k6Worker/k6.tar.gz; ls -al k6Worker' def frameOutFileName( self, frameNum ): return 'worker_%03d.*' % frameNum def frameCmd( self, frameNum ): cmd = 'cd k6Worker && ./k6 run -q script.js --out csv=~/worker_%03d.csv' % ( frameNum ) return cmd logger = logging.getLogger(__name__) logFmt = '%(asctime)s %(levelname)s %(module)s %(funcName)s %(message)s' logDateFmt = '%Y/%m/%d %H:%M:%S' formatter = logging.Formatter(fmt=logFmt, datefmt=logDateFmt ) logging.basicConfig(format=logFmt, datefmt=logDateFmt) time.datetime.now().strftime( '%Y-%m-%d_%H%M%S' ) outDataDir = 'data/k6_' + dateTimeTag if not os.path.isfile( 'k6Worker/k6.tar.gz' ): logger.error( 'the compressed k6 binary was not found, you may need to build and compress it' ) sys.exit( 1) try: rc = batchRunner.runBatch( frameProcessor = k6FrameProcessor(), commonInFilePath = 'k6Worker', authToken = os.getenv('NCS_AUTH_TOKEN') or 'YourAuthTokenHere', encryptFiles=False, timeLimit = 80*60, instTimeLimit = 7*60, frameTimeLimit = 14*60, filter = '{"dpr": ">=48","ram:":">=2800000000","app-version": ">=2.1.11"}', outDataDir = outDataDir, startFrame = 1, endFrame = 6, nWorkers = 10, limitOneFramePerWorker = True, autoscaleMax = 2 ) if os.path.isfile( outDataDir +'/recruitLaunched.json' ): rc2 = subprocess.call( [sys.executable, 'plotK6Output.py', '--dataDirPath', outDataDir], stdout=subprocess.DEVNULL ) if rc2: logger.warning( 'plotK6Output.py exited with returnCode %d', rc2 ) sys.exit( rc ) except KeyboardInterrupt: logger.warning( 'an interuption occurred')

true

f71324dfaa63416bbf64be7b19dd844864849f91

6,040

py

Python

axi-graphics-core/cl_display_test_pattern.py

cospan/pynq-projects

cfa3c401673805beaa82cb94121a30d00e108e3e

[ "MIT" ]

null

axi-graphics-core/cl_display_test_pattern.py

cospan/pynq-projects

cfa3c401673805beaa82cb94121a30d00e108e3e

[ "MIT" ]

null

axi-graphics-core/cl_display_test_pattern.py

cospan/pynq-projects

cfa3c401673805beaa82cb94121a30d00e108e3e

[ "MIT" ]

null

#! /usr/bin/env python3 # Copyright (c) 2021 Dave McCoy (dave.mccoy@cospandesign.com) # # NAME is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # any later version. # # NAME is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with NAME; If not, see <http://www.gnu.org/licenses/>. import sys import os import argparse import warnings import time from pynq import PL from pynq import Overlay from pynq.lib.video import * from pynq.lib.video.hierarchies import * sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir)) from drivers.video_mixer import VideoMixer from drivers.dynamic_clock import DynamicClock from drivers.timing_controller import TimingController from drivers.test_pattern_generator import TestPatternGenerator from drivers.test_pattern_generator import TestPatternID from drivers.axi_graphics import AXIGraphics NAME = os.path.basename(os.path.realpath(__file__)) DESCRIPTION = "\n" \ "\n" \ "usage: %s [options]\n" % NAME EPILOG = "\n" \ "\n" \ "Examples:\n" \ "\tSomething\n" \ "\n" def main(argv): #Parse out the commandline arguments parser = argparse.ArgumentParser( formatter_class=argparse.RawDescriptionHelpFormatter, description=DESCRIPTION, epilog=EPILOG ) parser.add_argument("-t", "--test", nargs=1, default=["something"]) parser.add_argument("-d", "--debug", action="store_true", help="Enable Debug Messages") args = parser.parse_args() print ("Running Script: %s" % NAME) if args.debug: print ("test: %s" % str(args.test[0])) BF = os.path.join("./data/system_wrapper.bit") if not os.path.exists(BF): print ("%s Doesn't exist Exiting!!" % BF) return else: print ("Found bit file!") ol = Overlay(BF) ol.download() print ("Bitfile downloaded!") print ("Starting Video") print ("Configuring Timing Controller") tc = TimingController("video/timing_generator") tc.reset() while (not tc.is_reset_done()): print (".") WIDTH = tc.get_generator_width() HEIGHT = tc.get_generator_height() print ("Image Size (Retrieved from Timing Controller): %d x %d" % (WIDTH, HEIGHT)) print ("Configuring Test Pattern Generator") tpg = TestPatternGenerator("video/v_tpg_0", debug = args.debug) tpg.set_image_size(WIDTH, HEIGHT) tpg.set_color_format_to_rgb() #tpg.set_color_bar_test_pattern() #tpg.set_test_pattern(TestPatternID.SOLID_RED) #tpg.set_test_pattern(TestPatternID.SOLID_WHITE) tpg.set_test_pattern(TestPatternID.SOLID_BLACK) #tpg.set_test_pattern(TestPatternID.COLOR_BARS) tpg.start() SUB_WIN_WIDTH = 640 SUB_WIN_HEIGHT = 480 #SUB_WIN_WIDTH = 16 #SUB_WIN_HEIGHT = 4 #SUB_WIN_WIDTH = WIDTH #SUB_WIN_HEIGHT = HEIGHT print ("Configuring Video Mixer") vm = VideoMixer("video/v_mix_0", WIDTH, HEIGHT) #vm.configure_layer(0, 0, 0, WIDTH, HEIGHT) vm.configure_layer(1, 0, 0, SUB_WIN_WIDTH, SUB_WIN_HEIGHT) vm.enable_layer(1, True) vm.configure_master_layer(WIDTH, HEIGHT) #vm.enable_overlay_layer(True) if args.debug: print ("Video Mixer Control Register Before Enable: 0x%08X" % vm.get_control()) vm.start() if args.debug: print ("Video Mixer Control Register After Enable: 0x%08X" % vm.get_control()) print ("Enable Master Layer (Test Pattern) Output") vm.enable_master_layer(True) if args.debug: print ("VM Settings:") if args.debug: print (" x pos: %d" % vm.get_layer_x(0)) if args.debug: print (" y pos: %d" % vm.get_layer_y(0)) if args.debug: print (" width: %d" % vm.get_layer_width(0)) if args.debug: print (" height: %d" % vm.get_layer_height(0)) if args.debug: print (" scale: %d" % vm.get_layer_scale(0)) if args.debug: print (" alpha: %d" % vm.get_layer_alpha(0)) if args.debug: print (" stride: %d" % vm.get_layer_stride(0)) if args.debug: print (" p1 Addr: %d" % vm.get_layer_plane1_addr(0)) if args.debug: print (" p2 Addr: %d" % vm.get_layer_plane2_addr(0)) if args.debug: print ("Layer Settings: 0x%08X" % vm.get_layer_enable_reg()) g0 = ol.low_speed.axi_gpio_0 g0.write(0x0C, 0x01) tc.enable(gen_enable = True, use_gen_src = True) if args.debug: print ("TC Control Register: 0x%08X" % tc.get_control_reg()) print ("Interfacing with AXI Graphics Controller: \n") print ("%s" % str(ol.ip_dict["video/axi_graphics_0"])) ag = AXIGraphics("video/axi_graphics_0", debug = args.debug) #print ("AXI Graphics Started: %s" % str(ol.ip_dict["video/axi_graphics"])) #time.sleep(0.1) #time.sleep(5) print ("AXI Graphics Control Register: 0x%08X" % ag.get_control()) #print ("AXI Graphics: 0x%08X" % ag.get_version()) ag.set_width(SUB_WIN_WIDTH) ag.set_height(SUB_WIN_HEIGHT) print ("Size: %d x %d" % (ag.get_width(), ag.get_height())) #ag.set_mode(0) # Black #ag.set_mode(1) # White #ag.set_mode(2) # Red #ag.set_mode(3) # Green #ag.set_mode(4) # Blue ag.set_mode(5) # Color Bars #ag.set_mode(6) # Block #ag.set_mode(7) # Ramp ag.set_alpha(0xFF) ag.set_ref0_xy(100, 100) ag.set_ref1_xy(200, 200) ag.set_interval(100) ag.enable_rgba_format(True) #ag.enable_rgba_format(False) ag.enable(True) print ("AXI Graphics Control Register: 0x%08X" % ag.get_control()) #print ("Sleeping for 5 seconds") #time.sleep(5) if __name__ == "__main__": main(sys.argv)

33.743017

98

0.664238

import sys import os import argparse import warnings import time from pynq import PL from pynq import Overlay from pynq.lib.video import * from pynq.lib.video.hierarchies import * sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir)) from drivers.video_mixer import VideoMixer from drivers.dynamic_clock import DynamicClock from drivers.timing_controller import TimingController from drivers.test_pattern_generator import TestPatternGenerator from drivers.test_pattern_generator import TestPatternID from drivers.axi_graphics import AXIGraphics NAME = os.path.basename(os.path.realpath(__file__)) DESCRIPTION = "\n" \ "\n" \ "usage: %s [options]\n" % NAME EPILOG = "\n" \ "\n" \ "Examples:\n" \ "\tSomething\n" \ "\n" def main(argv): parser = argparse.ArgumentParser( formatter_class=argparse.RawDescriptionHelpFormatter, description=DESCRIPTION, epilog=EPILOG ) parser.add_argument("-t", "--test", nargs=1, default=["something"]) parser.add_argument("-d", "--debug", action="store_true", help="Enable Debug Messages") args = parser.parse_args() print ("Running Script: %s" % NAME) if args.debug: print ("test: %s" % str(args.test[0])) BF = os.path.join("./data/system_wrapper.bit") if not os.path.exists(BF): print ("%s Doesn't exist Exiting!!" % BF) return else: print ("Found bit file!") ol = Overlay(BF) ol.download() print ("Bitfile downloaded!") print ("Starting Video") print ("Configuring Timing Controller") tc = TimingController("video/timing_generator") tc.reset() while (not tc.is_reset_done()): print (".") WIDTH = tc.get_generator_width() HEIGHT = tc.get_generator_height() print ("Image Size (Retrieved from Timing Controller): %d x %d" % (WIDTH, HEIGHT)) print ("Configuring Test Pattern Generator") tpg = TestPatternGenerator("video/v_tpg_0", debug = args.debug) tpg.set_image_size(WIDTH, HEIGHT) tpg.set_color_format_to_rgb() #tpg.set_color_bar_test_pattern() #tpg.set_test_pattern(TestPatternID.SOLID_RED) #tpg.set_test_pattern(TestPatternID.SOLID_WHITE) tpg.set_test_pattern(TestPatternID.SOLID_BLACK) #tpg.set_test_pattern(TestPatternID.COLOR_BARS) tpg.start() SUB_WIN_WIDTH = 640 SUB_WIN_HEIGHT = 480 #SUB_WIN_WIDTH = 16 #SUB_WIN_HEIGHT = 4 #SUB_WIN_WIDTH = WIDTH #SUB_WIN_HEIGHT = HEIGHT print ("Configuring Video Mixer") vm = VideoMixer("video/v_mix_0", WIDTH, HEIGHT) #vm.configure_layer(0, 0, 0, WIDTH, HEIGHT) vm.configure_layer(1, 0, 0, SUB_WIN_WIDTH, SUB_WIN_HEIGHT) vm.enable_layer(1, True) vm.configure_master_layer(WIDTH, HEIGHT) #vm.enable_overlay_layer(True) if args.debug: print ("Video Mixer Control Register Before Enable: 0x%08X" % vm.get_control()) vm.start() if args.debug: print ("Video Mixer Control Register After Enable: 0x%08X" % vm.get_control()) print ("Enable Master Layer (Test Pattern) Output") vm.enable_master_layer(True) if args.debug: print ("VM Settings:") if args.debug: print (" x pos: %d" % vm.get_layer_x(0)) if args.debug: print (" y pos: %d" % vm.get_layer_y(0)) if args.debug: print (" width: %d" % vm.get_layer_width(0)) if args.debug: print (" height: %d" % vm.get_layer_height(0)) if args.debug: print (" scale: %d" % vm.get_layer_scale(0)) if args.debug: print (" alpha: %d" % vm.get_layer_alpha(0)) if args.debug: print (" stride: %d" % vm.get_layer_stride(0)) if args.debug: print (" p1 Addr: %d" % vm.get_layer_plane1_addr(0)) if args.debug: print (" p2 Addr: %d" % vm.get_layer_plane2_addr(0)) if args.debug: print ("Layer Settings: 0x%08X" % vm.get_layer_enable_reg()) g0 = ol.low_speed.axi_gpio_0 g0.write(0x0C, 0x01) tc.enable(gen_enable = True, use_gen_src = True) if args.debug: print ("TC Control Register: 0x%08X" % tc.get_control_reg()) print ("Interfacing with AXI Graphics Controller: \n") print ("%s" % str(ol.ip_dict["video/axi_graphics_0"])) ag = AXIGraphics("video/axi_graphics_0", debug = args.debug) #print ("AXI Graphics Started: %s" % str(ol.ip_dict["video/axi_graphics"])) #time.sleep(0.1) #time.sleep(5) print ("AXI Graphics Control Register: 0x%08X" % ag.get_control()) #print ("AXI Graphics: 0x%08X" % ag.get_version()) ag.set_width(SUB_WIN_WIDTH) ag.set_height(SUB_WIN_HEIGHT) print ("Size: %d x %d" % (ag.get_width(), ag.get_height())) #ag.set_mode(0) # Black #ag.set_mode(1) # White #ag.set_mode(2) # Red #ag.set_mode(3) # Green #ag.set_mode(4) # Blue ag.set_mode(5) # Color Bars #ag.set_mode(6) # Block #ag.set_mode(7) # Ramp ag.set_alpha(0xFF) ag.set_ref0_xy(100, 100) ag.set_ref1_xy(200, 200) ag.set_interval(100) ag.enable_rgba_format(True) #ag.enable_rgba_format(False) ag.enable(True) print ("AXI Graphics Control Register: 0x%08X" % ag.get_control()) #print ("Sleeping for 5 seconds") #time.sleep(5) if __name__ == "__main__": main(sys.argv)

true

f71325a3ea894d6c864be41df09c1683f96d26f8

1,052

py

Python

environments/template_test.py

lavanyashukla/ml-fairness-gym

fb68b379d4284b7af746b2a051d518b3bd45ab00

[ "Apache-2.0" ]

null

environments/template_test.py

lavanyashukla/ml-fairness-gym

fb68b379d4284b7af746b2a051d518b3bd45ab00

[ "Apache-2.0" ]

null

environments/template_test.py

lavanyashukla/ml-fairness-gym

fb68b379d4284b7af746b2a051d518b3bd45ab00

[ "Apache-2.0" ]

null

# coding=utf-8 # Copyright 2019 The ML Fairness Gym Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Tests for fairness_gym.environments.template.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function from absl.testing import absltest import test_util from environments import template class TemplateTest(absltest.TestCase): def test_example_environment_can_run(self): test_util.run_test_simulation(env=template.ExampleEnv()) if __name__ == '__main__': absltest.main()

30.057143

74

0.78327

from __future__ import absolute_import from __future__ import division from __future__ import print_function from absl.testing import absltest import test_util from environments import template class TemplateTest(absltest.TestCase): def test_example_environment_can_run(self): test_util.run_test_simulation(env=template.ExampleEnv()) if __name__ == '__main__': absltest.main()

true

f713270aa0014ff12f937841b5f52db6c244f221

3,484

py

Python

djangocms_text_ckeditor/utils.py

ScholzVolkmer/djangocms-text-ckeditor

f904b09f5a0080458edc1f14de29d67f51d2e2c5

[ "BSD-3-Clause" ]

1

2017-05-12T06:24:24.000Z

djangocms_text_ckeditor/utils.py

timgraham/djangocms-text-ckeditor

c2fba71969ab12a521bf15af93035a1b13892191

[ "BSD-3-Clause" ]

null

djangocms_text_ckeditor/utils.py

timgraham/djangocms-text-ckeditor

c2fba71969ab12a521bf15af93035a1b13892191

[ "BSD-3-Clause" ]

null

import re from django.template.defaultfilters import force_escape import django from cms.models import CMSPlugin from cms.plugins.utils import downcast_plugins from distutils.version import LooseVersion from django.utils.functional import LazyObject from django.core.files.storage import get_storage_class import os OBJ_ADMIN_RE_PATTERN = r'<img [^>]*\bid="plugin_obj_(\d+)"[^>]*/?>' OBJ_ADMIN_RE = re.compile(OBJ_ADMIN_RE_PATTERN) def plugin_to_tag(obj): return u'<img src="%(icon_src)s" alt="%(icon_alt)s" title="%(icon_alt)s" id="plugin_obj_%(id)d" />' % \ dict(id=obj.id, icon_src=force_escape(obj.get_instance_icon_src()), icon_alt=force_escape(obj.get_instance_icon_alt()), ) def plugin_tags_to_id_list(text, regex=OBJ_ADMIN_RE): ids = regex.findall(text) return [int(id) for id in ids if id.isdigit()] def plugin_tags_to_user_html(text, context, placeholder): """ Convert plugin object 'tags' into the form for public site. context is the template context to use, placeholder is the placeholder name """ plugin_map = _plugin_dict(text) def _render_tag(m): plugin_id = int(m.groups()[0]) try: obj = plugin_map[plugin_id] obj._render_meta.text_enabled = True except KeyError: # Object must have been deleted. It cannot be rendered to # end user so just remove it from the HTML altogether return u'' return obj.render_plugin(context, placeholder) return OBJ_ADMIN_RE.sub(_render_tag, text) def replace_plugin_tags(text, id_dict): def _replace_tag(m): plugin_id = int(m.groups()[0]) new_id = id_dict.get(plugin_id) try: obj = CMSPlugin.objects.get(pk=new_id) except CMSPlugin.DoesNotExist: # Object must have been deleted. It cannot be rendered to # end user, or edited, so just remove it from the HTML # altogether return u'' return u'<img src="%(icon_src)s" alt="%(icon_alt)s" title="%(icon_alt)s" id="plugin_obj_%(id)d" />' % \ dict(id=new_id, icon_src=force_escape(obj.get_instance_icon_src()), icon_alt=force_escape(obj.get_instance_icon_alt()), ) return OBJ_ADMIN_RE.sub(_replace_tag, text) def _plugin_dict(text, regex=OBJ_ADMIN_RE): plugin_ids = plugin_tags_to_id_list(text, regex) plugin_list = downcast_plugins(CMSPlugin.objects.filter(pk__in=plugin_ids), select_placeholder=True) return dict((plugin.pk, plugin) for plugin in plugin_list) """ The following class is taken from https://github.com/jezdez/django/compare/feature/staticfiles-templatetag and should be removed and replaced by the django-core version in 1.4 """ default_storage = 'django.contrib.staticfiles.storage.StaticFilesStorage' if LooseVersion(django.get_version()) < LooseVersion('1.3'): default_storage = 'staticfiles.storage.StaticFilesStorage' class ConfiguredStorage(LazyObject): def _setup(self): from django.conf import settings self._wrapped = get_storage_class(getattr(settings, 'STATICFILES_STORAGE', default_storage))() configured_storage = ConfiguredStorage() def static_url(path): ''' Helper that prefixes a URL with STATIC_URL and cms ''' if not path: return '' return configured_storage.url(os.path.join('', path))

37.462366

111

0.679392

import re from django.template.defaultfilters import force_escape import django from cms.models import CMSPlugin from cms.plugins.utils import downcast_plugins from distutils.version import LooseVersion from django.utils.functional import LazyObject from django.core.files.storage import get_storage_class import os OBJ_ADMIN_RE_PATTERN = r'<img [^>]*\bid="plugin_obj_(\d+)"[^>]*/?>' OBJ_ADMIN_RE = re.compile(OBJ_ADMIN_RE_PATTERN) def plugin_to_tag(obj): return u'<img src="%(icon_src)s" alt="%(icon_alt)s" title="%(icon_alt)s" id="plugin_obj_%(id)d" />' % \ dict(id=obj.id, icon_src=force_escape(obj.get_instance_icon_src()), icon_alt=force_escape(obj.get_instance_icon_alt()), ) def plugin_tags_to_id_list(text, regex=OBJ_ADMIN_RE): ids = regex.findall(text) return [int(id) for id in ids if id.isdigit()] def plugin_tags_to_user_html(text, context, placeholder): plugin_map = _plugin_dict(text) def _render_tag(m): plugin_id = int(m.groups()[0]) try: obj = plugin_map[plugin_id] obj._render_meta.text_enabled = True except KeyError: return u'' return obj.render_plugin(context, placeholder) return OBJ_ADMIN_RE.sub(_render_tag, text) def replace_plugin_tags(text, id_dict): def _replace_tag(m): plugin_id = int(m.groups()[0]) new_id = id_dict.get(plugin_id) try: obj = CMSPlugin.objects.get(pk=new_id) except CMSPlugin.DoesNotExist: return u'' return u'<img src="%(icon_src)s" alt="%(icon_alt)s" title="%(icon_alt)s" id="plugin_obj_%(id)d" />' % \ dict(id=new_id, icon_src=force_escape(obj.get_instance_icon_src()), icon_alt=force_escape(obj.get_instance_icon_alt()), ) return OBJ_ADMIN_RE.sub(_replace_tag, text) def _plugin_dict(text, regex=OBJ_ADMIN_RE): plugin_ids = plugin_tags_to_id_list(text, regex) plugin_list = downcast_plugins(CMSPlugin.objects.filter(pk__in=plugin_ids), select_placeholder=True) return dict((plugin.pk, plugin) for plugin in plugin_list) default_storage = 'django.contrib.staticfiles.storage.StaticFilesStorage' if LooseVersion(django.get_version()) < LooseVersion('1.3'): default_storage = 'staticfiles.storage.StaticFilesStorage' class ConfiguredStorage(LazyObject): def _setup(self): from django.conf import settings self._wrapped = get_storage_class(getattr(settings, 'STATICFILES_STORAGE', default_storage))() configured_storage = ConfiguredStorage() def static_url(path): if not path: return '' return configured_storage.url(os.path.join('', path))

true

f713279f339de53315b9bedd03943a57f87d6559

1,537

py

Python

nets/classifiernet.py

Luciano233/OCR_Japanease

055bdd0cc8e4d053dfb471cd642b1616ba0938d1

[ "MIT" ]

1

2021-03-15T02:57:21.000Z

nets/classifiernet.py

Luciano233/OCR_Japanease

055bdd0cc8e4d053dfb471cd642b1616ba0938d1

[ "MIT" ]

null

nets/classifiernet.py

Luciano233/OCR_Japanease

055bdd0cc8e4d053dfb471cd642b1616ba0938d1

[ "MIT" ]

null

import torch import torch.nn as nn import torch.nn.functional as F from .block import Mish, SeparableConv2d, Block class WideTipXception(nn.Module): def __init__(self, num_class): super(WideTipXception, self).__init__() self.conv1 = nn.Conv2d(1, 192, 3, 2, 1, bias=True) self.bn1 = nn.BatchNorm2d(192) self.mish = Mish() self.conv2 = nn.Conv2d(192, 512, 3, 1, 1, bias=True) self.bn2 = nn.BatchNorm2d(512) self.block1 = Block(512,1024,3,1) self.block2 = Block(1024,1024,3,1) self.block3 = Block(1024,1024,3,1) self.block4 = Block(1024,1024,3,1) self.block5 = Block(1024,1024,3,1) self.block6 = Block(1024,2048,2,2) self.block7 = Block(2048,3072,2,2) self.conv3 = SeparableConv2d(3072,4096,3,stride=1,padding=0,bias=True) self.fc = nn.Linear(4096, num_class) def forward(self, input): x = self.conv1(input) x = self.bn1(x) x = self.mish(x) x = self.conv2(x) x = self.bn2(x) x = self.block1(x) x = self.block2(x) x = self.block3(x) x = self.block4(x) x = self.block5(x) x = self.block6(x) x = self.block7(x) x = self.mish(x) x = self.conv3(x) x = self.mish(x) x = F.adaptive_avg_pool2d(x, (1, 1)) x = x.view(x.size(0), -1) result = self.fc(x) return result def get_classifiernet(num_class): model = WideTipXception(num_class) return model

26.5

78

0.570592

import torch import torch.nn as nn import torch.nn.functional as F from .block import Mish, SeparableConv2d, Block class WideTipXception(nn.Module): def __init__(self, num_class): super(WideTipXception, self).__init__() self.conv1 = nn.Conv2d(1, 192, 3, 2, 1, bias=True) self.bn1 = nn.BatchNorm2d(192) self.mish = Mish() self.conv2 = nn.Conv2d(192, 512, 3, 1, 1, bias=True) self.bn2 = nn.BatchNorm2d(512) self.block1 = Block(512,1024,3,1) self.block2 = Block(1024,1024,3,1) self.block3 = Block(1024,1024,3,1) self.block4 = Block(1024,1024,3,1) self.block5 = Block(1024,1024,3,1) self.block6 = Block(1024,2048,2,2) self.block7 = Block(2048,3072,2,2) self.conv3 = SeparableConv2d(3072,4096,3,stride=1,padding=0,bias=True) self.fc = nn.Linear(4096, num_class) def forward(self, input): x = self.conv1(input) x = self.bn1(x) x = self.mish(x) x = self.conv2(x) x = self.bn2(x) x = self.block1(x) x = self.block2(x) x = self.block3(x) x = self.block4(x) x = self.block5(x) x = self.block6(x) x = self.block7(x) x = self.mish(x) x = self.conv3(x) x = self.mish(x) x = F.adaptive_avg_pool2d(x, (1, 1)) x = x.view(x.size(0), -1) result = self.fc(x) return result def get_classifiernet(num_class): model = WideTipXception(num_class) return model

true

f71327a3a8d91361d562cf3cb209adc3828acd01

122

py

Python

sub_call/file_call.py

jyhh1992/test_algorithm

1e6ec7dbdd6881f0c60fbf7c6d7d6f8f4a5b2168

[ "Apache-2.0" ]

null

sub_call/file_call.py

jyhh1992/test_algorithm

1e6ec7dbdd6881f0c60fbf7c6d7d6f8f4a5b2168

[ "Apache-2.0" ]

null

sub_call/file_call.py

jyhh1992/test_algorithm

1e6ec7dbdd6881f0c60fbf7c6d7d6f8f4a5b2168

[ "Apache-2.0" ]

null

class response(): def __init__(self) -> None: self.num = 5 def call_result(self): return(self.num)

24.4

31

0.581967

class response(): def __init__(self) -> None: self.num = 5 def call_result(self): return(self.num)

true

f71327e11b6b984a1e61a91092f5d829f200915d

4,572

py

Python

InLine_Implementation/Code/utils/fftutils.py

HMS-CardiacMR/MyoMapNet-Myocardial-Parametric-Mapping

1e2dee8d6d1f97722eba91618462537faf9efba7

[ "MIT" ]

4

2021-12-15T22:57:44.000Z

2022-03-18T14:02:15.000Z

InLine_Implementation/Code/utils/fftutils.py

HMS-CardiacMR/MyoMapNet

1e2dee8d6d1f97722eba91618462537faf9efba7

[ "MIT" ]

null

InLine_Implementation/Code/utils/fftutils.py

HMS-CardiacMR/MyoMapNet

1e2dee8d6d1f97722eba91618462537faf9efba7

[ "MIT" ]

null

from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np import torch ################################################################################ ################################################################################ def roll_nn(X, axis, n): f_idx = tuple(slice(None, None, None) if i != axis else slice(0, n, None) for i in range(X.dim())) b_idx = tuple(slice(None, None, None) if i != axis else slice(n, None, None) for i in range(X.dim())) front = X[f_idx] back = X[b_idx] return torch.cat([back, front], axis) def fftshift2d(x, dims = [2, 3]): real, imag = torch.unbind(x, -1) for dim in dims: n_shift = real.size(dim)//2 if real.size(dim) % 2 != 0: n_shift += 1 # for odd-sized images real = roll_nn(real, axis=dim, n=n_shift) imag = roll_nn(imag, axis=dim, n=n_shift) return torch.stack((real, imag), -1) # last dim=2 (real&imag) def ifftshift2d(x, dims = [2, 3]): real, imag = torch.unbind(x, -1) for dim in dims[::-1]: real = roll_nn(real, axis=dim, n=real.size(dim)//2) imag = roll_nn(imag, axis=dim, n=imag.size(dim)//2) return torch.stack((real, imag), -1) # last dim=2 (real&imag) ################################################################################ ################################################################################ def roll_n(X, axis, n): f_idx = tuple(slice(None, None, None) if i != axis else slice(0, n, None) for i in range(X.dim())) b_idx = tuple(slice(None, None, None) if i != axis else slice(n, None, None) for i in range(X.dim())) front = X[f_idx] back = X[b_idx] return torch.cat([back, front], axis) def batch_fftshift2d(x, dims = [-2, -3]): real, imag = torch.unbind(x, -1) for dim in range(1, len(real.size())): n_shift = real.size(dim)//2 if real.size(dim) % 2 != 0: n_shift += 1 # for odd-sized images real = roll_n(real, axis=dim, n=n_shift) imag = roll_n(imag, axis=dim, n=n_shift) return torch.stack((real, imag), -1) # last dim=2 (real&imag) def batch_ifftshift2d(x): real, imag = torch.unbind(x, -1) for dim in range(len(real.size()) - 1, 0, -1): real = roll_n(real, axis=dim, n=real.size(dim)//2) imag = roll_n(imag, axis=dim, n=imag.size(dim)//2) return torch.stack((real, imag), -1) # last dim=2 (real&imag) ################################################################################ ################################################################################ def prepare_grid(m, n): x = np.linspace(-(m // 2)/(m / 2), (m // 2)/(m / 2) - (1 - m % 2)*2/m, num=m) y = np.linspace(-(n // 2)/(n / 2), (n // 2)/(n / 2) - (1 - n % 2)*2/n, num=n) xv, yv = np.meshgrid(y, x) angle = np.arctan2(yv, xv) rad = np.sqrt(xv**2 + yv**2) rad[m//2][n//2] = rad[m//2][n//2 - 1] log_rad = np.log2(rad) return log_rad, angle def rcosFn(width, position): N = 256 # abritrary X = np.pi * np.array(range(-N-1, 2))/2/N Y = np.cos(X)**2 Y[0] = Y[1] Y[N+2] = Y[N+1] X = position + 2*width/np.pi*(X + np.pi/4) return X, Y def pointOp(im, Y, X): out = np.interp(im.flatten(), X, Y) return np.reshape(out, im.shape) def getlist(coeff): straight = [bands for scale in coeff[1:-1] for bands in scale] straight = [coeff[0]] + straight + [coeff[-1]] return straight ################################################################################ # NumPy reference implementation (fftshift and ifftshift) # def fftshift(x, axes=None): # """ # Shift the zero-frequency component to the center of the spectrum. # This function swaps half-spaces for all axes listed (defaults to all). # Note that ``y[0]`` is the Nyquist component only if ``len(x)`` is even. # Parameters # """ # x = np.asarray(x) # if axes is None: # axes = tuple(range(x.ndim)) # shift = [dim // 2 for dim in x.shape] # shift = [x.shape[ax] // 2 for ax in axes] # return np.roll(x, shift, axes) # # def ifftshift(x, axes=None): # """ # The inverse of `fftshift`. Although identical for even-length `x`, the # functions differ by one sample for odd-length `x`. # """ # x = np.asarray(x) # if axes is None: # axes = tuple(range(x.ndim)) # shift = [-(dim // 2) for dim in x.shape] # shift = [-(x.shape[ax] // 2) for ax in axes] # return np.roll(x, shift, axes)

36

105

0.506124

from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np import torch

true

f71328387c1b0d3869902786c8e5c2618cf07880

30

py

Python

mysql-utilities-1.6.0/mysql/utilities/command/__init__.py

bopopescu/mysql-dbcompare

1e912fd87282be3b3bed48487e6beb0ecb1de339

[ "Apache-2.0" ]

2

2018-03-20T07:42:58.000Z

2018-03-20T07:43:49.000Z

mysql-utilities-1.6.0/mysql/utilities/command/__init__.py

bopopescu/mysql-dbcompare

1e912fd87282be3b3bed48487e6beb0ecb1de339

[ "Apache-2.0" ]

null

mysql-utilities-1.6.0/mysql/utilities/command/__init__.py

bopopescu/mysql-dbcompare

1e912fd87282be3b3bed48487e6beb0ecb1de339

[ "Apache-2.0" ]

1

2020-07-23T23:07:08.000Z

"""mysql.utilities.command"""

15

29

0.7

true

f7132c280ff6ae8c29cb3a2ef4deefb0f5dd9c3c

7,980

py

Python

deep-coref/modified_keras/examples/babi_memnn.py

natemalek/molen-pater-nathan-rma-thesis-coreference-with-singletons

3d2d6c751eadd6438a80b0c24f48b2635bc6acc7

[ "MIT" ]

null

deep-coref/modified_keras/examples/babi_memnn.py

natemalek/molen-pater-nathan-rma-thesis-coreference-with-singletons

3d2d6c751eadd6438a80b0c24f48b2635bc6acc7

[ "MIT" ]

null

deep-coref/modified_keras/examples/babi_memnn.py

natemalek/molen-pater-nathan-rma-thesis-coreference-with-singletons

3d2d6c751eadd6438a80b0c24f48b2635bc6acc7

[ "MIT" ]

null

from __future__ import print_function from keras.models import Sequential from keras.layers.embeddings import Embedding from keras.layers.core import Activation, Dense, Merge, Permute, Dropout from keras.layers.recurrent import LSTM from keras.datasets.data_utils import get_file from keras.preprocessing.sequence import pad_sequences from functools import reduce import tarfile import numpy as np import re """ Train a memory network on the bAbI dataset. References: - Jason Weston, Antoine Bordes, Sumit Chopra, Tomas Mikolov, Alexander M. Rush, "Towards AI-Complete Question Answering: A Set of Prerequisite Toy Tasks", http://arxiv.org/abs/1503.08895 - Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, Rob Fergus, "End-To-End Memory Networks", http://arxiv.org/abs/1503.08895 Reaches 93% accuracy on task 'single_supporting_fact_10k' after 70 epochs. Time per epoch: 3s on CPU (core i7). """ def tokenize(sent): '''Return the tokens of a sentence including punctuation. >>> tokenize('Bob dropped the apple. Where is the apple?') ['Bob', 'dropped', 'the', 'apple', '.', 'Where', 'is', 'the', 'apple', '?'] ''' return [x.strip() for x in re.split('(\W+)?', sent) if x.strip()] def parse_stories(lines, only_supporting=False): '''Parse stories provided in the bAbi tasks format If only_supporting is true, only the sentences that support the answer are kept. ''' data = [] story = [] for line in lines: line = line.decode('utf-8').strip() nid, line = line.split(' ', 1) nid = int(nid) if nid == 1: story = [] if '\t' in line: q, a, supporting = line.split('\t') q = tokenize(q) substory = None if only_supporting: # Only select the related substory supporting = map(int, supporting.split()) substory = [story[i - 1] for i in supporting] else: # Provide all the substories substory = [x for x in story if x] data.append((substory, q, a)) story.append('') else: sent = tokenize(line) story.append(sent) return data def get_stories(f, only_supporting=False, max_length=None): '''Given a file name, read the file, retrieve the stories, and then convert the sentences into a single story. If max_length is supplied, any stories longer than max_length tokens will be discarded. ''' data = parse_stories(f.readlines(), only_supporting=only_supporting) flatten = lambda data: reduce(lambda x, y: x + y, data) data = [(flatten(story), q, answer) for story, q, answer in data if not max_length or len(flatten(story)) < max_length] return data def vectorize_stories(data, word_idx, story_maxlen, query_maxlen): X = [] Xq = [] Y = [] for story, query, answer in data: x = [word_idx[w] for w in story] xq = [word_idx[w] for w in query] y = np.zeros(len(word_idx) + 1) # let's not forget that index 0 is reserved y[word_idx[answer]] = 1 X.append(x) Xq.append(xq) Y.append(y) return (pad_sequences(X, maxlen=story_maxlen), pad_sequences(Xq, maxlen=query_maxlen), np.array(Y)) path = get_file('babi-tasks-v1-2.tar.gz', origin='http://www.thespermwhale.com/jaseweston/babi/tasks_1-20_v1-2.tar.gz') tar = tarfile.open(path) challenges = { # QA1 with 10,000 samples 'single_supporting_fact_10k': 'tasks_1-20_v1-2/en-10k/qa1_single-supporting-fact_{}.txt', # QA2 with 10,000 samples 'two_supporting_facts_10k': 'tasks_1-20_v1-2/en-10k/qa2_two-supporting-facts_{}.txt', } challenge_type = 'single_supporting_fact_10k' challenge = challenges[challenge_type] print('Extracting stories for the challenge:', challenge_type) train_stories = get_stories(tar.extractfile(challenge.format('train'))) test_stories = get_stories(tar.extractfile(challenge.format('test'))) vocab = sorted(reduce(lambda x, y: x | y, (set(story + q + [answer]) for story, q, answer in train_stories + test_stories))) # Reserve 0 for masking via pad_sequences vocab_size = len(vocab) + 1 story_maxlen = max(map(len, (x for x, _, _ in train_stories + test_stories))) query_maxlen = max(map(len, (x for _, x, _ in train_stories + test_stories))) print('-') print('Vocab size:', vocab_size, 'unique words') print('Story max length:', story_maxlen, 'words') print('Query max length:', query_maxlen, 'words') print('Number of training stories:', len(train_stories)) print('Number of test stories:', len(test_stories)) print('-') print('Here\'s what a "story" tuple looks like (input, query, answer):') print(train_stories[0]) print('-') print('Vectorizing the word sequences...') word_idx = dict((c, i + 1) for i, c in enumerate(vocab)) inputs_train, queries_train, answers_train = vectorize_stories(train_stories, word_idx, story_maxlen, query_maxlen) inputs_test, queries_test, answers_test = vectorize_stories(test_stories, word_idx, story_maxlen, query_maxlen) print('-') print('inputs: integer tensor of shape (samples, max_length)') print('inputs_train shape:', inputs_train.shape) print('inputs_test shape:', inputs_test.shape) print('-') print('queries: integer tensor of shape (samples, max_length)') print('queries_train shape:', queries_train.shape) print('queries_test shape:', queries_test.shape) print('-') print('answers: binary (1 or 0) tensor of shape (samples, vocab_size)') print('answers_train shape:', answers_train.shape) print('answers_test shape:', answers_test.shape) print('-') print('Compiling...') # embed the input sequence into a sequence of vectors input_encoder_m = Sequential() input_encoder_m.add(Embedding(input_dim=vocab_size, output_dim=64, input_length=story_maxlen)) # output: (samples, story_maxlen, embedding_dim) # embed the question into a single vector question_encoder = Sequential() question_encoder.add(Embedding(input_dim=vocab_size, output_dim=64, input_length=query_maxlen)) # output: (samples, query_maxlen, embedding_dim) # compute a 'match' between input sequence elements (which are vectors) # and the question vector match = Sequential() match.add(Merge([input_encoder_m, question_encoder], mode='dot', dot_axes=[(2,), (2,)])) # output: (samples, story_maxlen, query_maxlen) # embed the input into a single vector with size = story_maxlen: input_encoder_c = Sequential() input_encoder_c.add(Embedding(input_dim=vocab_size, output_dim=query_maxlen, input_length=story_maxlen)) # output: (samples, story_maxlen, query_maxlen) # sum the match vector with the input vector: response = Sequential() response.add(Merge([match, input_encoder_c], mode='sum')) # output: (samples, story_maxlen, query_maxlen) response.add(Permute((2, 1))) # output: (samples, query_maxlen, story_maxlen) # concatenate the match vector with the question vector, # and do logistic regression on top answer = Sequential() answer.add(Merge([response, question_encoder], mode='concat', concat_axis=-1)) # the original paper uses a matrix multiplication for this reduction step. # we choose to use a RNN instead. answer.add(LSTM(64)) # one regularization layer -- more would probably be needed. answer.add(Dropout(0.25)) answer.add(Dense(vocab_size)) # we output a probability distribution over the vocabulary answer.add(Activation('softmax')) answer.compile(optimizer='rmsprop', loss='categorical_crossentropy') # Note: you could use a Graph model to avoid repeat the input twice answer.fit([inputs_train, queries_train, inputs_train], answers_train, batch_size=32, nb_epoch=70, show_accuracy=True, validation_data=([inputs_test, queries_test, inputs_test], answers_test))

39.310345

124

0.686967

from __future__ import print_function from keras.models import Sequential from keras.layers.embeddings import Embedding from keras.layers.core import Activation, Dense, Merge, Permute, Dropout from keras.layers.recurrent import LSTM from keras.datasets.data_utils import get_file from keras.preprocessing.sequence import pad_sequences from functools import reduce import tarfile import numpy as np import re def tokenize(sent): return [x.strip() for x in re.split('(\W+)?', sent) if x.strip()] def parse_stories(lines, only_supporting=False): data = [] story = [] for line in lines: line = line.decode('utf-8').strip() nid, line = line.split(' ', 1) nid = int(nid) if nid == 1: story = [] if '\t' in line: q, a, supporting = line.split('\t') q = tokenize(q) substory = None if only_supporting: supporting = map(int, supporting.split()) substory = [story[i - 1] for i in supporting] else: substory = [x for x in story if x] data.append((substory, q, a)) story.append('') else: sent = tokenize(line) story.append(sent) return data def get_stories(f, only_supporting=False, max_length=None): data = parse_stories(f.readlines(), only_supporting=only_supporting) flatten = lambda data: reduce(lambda x, y: x + y, data) data = [(flatten(story), q, answer) for story, q, answer in data if not max_length or len(flatten(story)) < max_length] return data def vectorize_stories(data, word_idx, story_maxlen, query_maxlen): X = [] Xq = [] Y = [] for story, query, answer in data: x = [word_idx[w] for w in story] xq = [word_idx[w] for w in query] y = np.zeros(len(word_idx) + 1) y[word_idx[answer]] = 1 X.append(x) Xq.append(xq) Y.append(y) return (pad_sequences(X, maxlen=story_maxlen), pad_sequences(Xq, maxlen=query_maxlen), np.array(Y)) path = get_file('babi-tasks-v1-2.tar.gz', origin='http://www.thespermwhale.com/jaseweston/babi/tasks_1-20_v1-2.tar.gz') tar = tarfile.open(path) challenges = { # QA1 with 10,000 samples 'single_supporting_fact_10k': 'tasks_1-20_v1-2/en-10k/qa1_single-supporting-fact_{}.txt', # QA2 with 10,000 samples 'two_supporting_facts_10k': 'tasks_1-20_v1-2/en-10k/qa2_two-supporting-facts_{}.txt', } challenge_type = 'single_supporting_fact_10k' challenge = challenges[challenge_type] print('Extracting stories for the challenge:', challenge_type) train_stories = get_stories(tar.extractfile(challenge.format('train'))) test_stories = get_stories(tar.extractfile(challenge.format('test'))) vocab = sorted(reduce(lambda x, y: x | y, (set(story + q + [answer]) for story, q, answer in train_stories + test_stories))) # Reserve 0 for masking via pad_sequences vocab_size = len(vocab) + 1 story_maxlen = max(map(len, (x for x, _, _ in train_stories + test_stories))) query_maxlen = max(map(len, (x for _, x, _ in train_stories + test_stories))) print('-') print('Vocab size:', vocab_size, 'unique words') print('Story max length:', story_maxlen, 'words') print('Query max length:', query_maxlen, 'words') print('Number of training stories:', len(train_stories)) print('Number of test stories:', len(test_stories)) print('-') print('Here\'s what a "story" tuple looks like (input, query, answer):') print(train_stories[0]) print('-') print('Vectorizing the word sequences...') word_idx = dict((c, i + 1) for i, c in enumerate(vocab)) inputs_train, queries_train, answers_train = vectorize_stories(train_stories, word_idx, story_maxlen, query_maxlen) inputs_test, queries_test, answers_test = vectorize_stories(test_stories, word_idx, story_maxlen, query_maxlen) print('-') print('inputs: integer tensor of shape (samples, max_length)') print('inputs_train shape:', inputs_train.shape) print('inputs_test shape:', inputs_test.shape) print('-') print('queries: integer tensor of shape (samples, max_length)') print('queries_train shape:', queries_train.shape) print('queries_test shape:', queries_test.shape) print('-') print('answers: binary (1 or 0) tensor of shape (samples, vocab_size)') print('answers_train shape:', answers_train.shape) print('answers_test shape:', answers_test.shape) print('-') print('Compiling...') input_encoder_m = Sequential() input_encoder_m.add(Embedding(input_dim=vocab_size, output_dim=64, input_length=story_maxlen)) question_encoder = Sequential() question_encoder.add(Embedding(input_dim=vocab_size, output_dim=64, input_length=query_maxlen)) match = Sequential() match.add(Merge([input_encoder_m, question_encoder], mode='dot', dot_axes=[(2,), (2,)])) input_encoder_c = Sequential() input_encoder_c.add(Embedding(input_dim=vocab_size, output_dim=query_maxlen, input_length=story_maxlen)) response = Sequential() response.add(Merge([match, input_encoder_c], mode='sum')) response.add(Permute((2, 1))) answer = Sequential() answer.add(Merge([response, question_encoder], mode='concat', concat_axis=-1)) answer.add(LSTM(64)) answer.add(Dropout(0.25)) answer.add(Dense(vocab_size)) answer.add(Activation('softmax')) answer.compile(optimizer='rmsprop', loss='categorical_crossentropy') answer.fit([inputs_train, queries_train, inputs_train], answers_train, batch_size=32, nb_epoch=70, show_accuracy=True, validation_data=([inputs_test, queries_test, inputs_test], answers_test))

true

f7132cb4f7b81dafa54bd9ae118292ec0f392074

4,254

py

Python

scripts/poincare_embeddings.py

TatsuyaShirakawa/torchemb

b72912c7602537f368c16fdeb2bb6cf177b742be

[ "MIT" ]

null

scripts/poincare_embeddings.py

TatsuyaShirakawa/torchemb

b72912c7602537f368c16fdeb2bb6cf177b742be

[ "MIT" ]

null

scripts/poincare_embeddings.py

TatsuyaShirakawa/torchemb

b72912c7602537f368c16fdeb2bb6cf177b742be

[ "MIT" ]

null

''' A rouch implementation of the following paper M. Nickel+, "Poincaré Embeddings for Learning Hierarchical Representations", NeurIPS2017 https://arxiv.org/pdf/1705.08039.pdf ''' import argparse from pathlib import Path import itertools import math import numpy as np import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import (IterableDataset, RandomSampler, DataLoader) from gensim.corpora import Dictionary from tqdm import tqdm from torchemb.poincare_ball import PoincareBallEmbedding, PoincareBall parser = argparse.ArgumentParser('Poincare Embeddings') parser.add_argument('data_file', type=Path) parser.add_argument('result_file', type=Path) parser.add_argument('-e', '--embedding_dim', default=10, type=int) parser.add_argument('-m', '--max_epoch', default=200, type=int) parser.add_argument('-s', '--samples_per_iter', default=10000, type=int) parser.add_argument('-b', '--batch_size', default=512, type=int) parser.add_argument('-n', '--neg_size', default=10, type=int) parser.add_argument('-c', default=1, type=float) parser.add_argument('--lr', default=1.0e-3, type=float) parser.add_argument('--momentum', default=0.9, type=float) parser.add_argument('--seed', default=0, type=int) args = parser.parse_args() print(args) np.random.seed(args.seed) torch.manual_seed(args.seed) def load_data(data_file): data_file = Path(data_file) pairs = [] with data_file.open() as fin: for line in fin: a, b = line.strip().split('\t') pairs.append((a, b)) d = Dictionary(pairs) pairs = np.asarray([d.doc2idx(pair) for pair in pairs]) return d, pairs dictionary, pairs = load_data(args.data_file) print(len(dictionary), len(pairs)) class Dataset(IterableDataset): def __init__(self, pairs, neg_size): self.pairs = pairs self.neg_size = neg_size self.pair_sampler = RandomSampler(list(range(len(self.pairs))), replacement=True) def __iter__(self): pair_iter = itertools.cycle(iter(self.pair_sampler)) while True: idx = next(pair_iter) x, y = self.pairs[idx] ys = [y] + [self.pairs[next(pair_iter)][1] for _ in range(self.neg_size - 1)] yield x, torch.LongTensor(ys) data = DataLoader(Dataset(pairs, args.neg_size), batch_size=args.batch_size) embeddings = PoincareBallEmbedding(len(dictionary), args.embedding_dim, c=args.c) manifold = PoincareBall(c=args.c) loss = nn.CrossEntropyLoss() warmup_rate = 100 lr = args.lr * (args.batch_size ** 0.5) / (args.embedding_dim ** 0.5) optimizer = optim.Adam(embeddings.parameters(), lr=lr) lr_scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=math.exp(math.log(0.01) / args.max_epoch)) def train(embeddings, loss, optimizer, data, samples_per_iter): embeddings.train() data_iter = iter(data) avg_loss_ = 0 N = samples_per_iter // args.batch_size for i in tqdm(range(N)): idx1, idx2 = next(data_iter) x, ys = embeddings(idx1), embeddings(idx2) assert(not torch.any(torch.isnan(x))) assert(not torch.any(torch.isnan(ys))) ds = manifold.distance(x[:, None, :].expand_as(ys), ys) logits = -ds loss_ = loss(logits, torch.zeros(len(logits), dtype=torch.long)) optimizer.zero_grad() loss_.backward() optimizer.step() avg_loss_ += loss_.item() avg_loss_ /= N print('train loss: {:.5f}'.format(avg_loss_)) def save(embeddings, dictionary, result_file): embeddings.eval() result_file = Path(result_file) result_file.parent.mkdir(parents=True, exist_ok=True) with torch.no_grad(): with result_file.open('w') as fout: for i, c in sorted(dictionary.dfs.items()): e = embeddings(torch.LongTensor([i]))[0] print(dictionary[i], *[_.item() for _ in e], sep='\t', file=fout) for epoch in range(args.max_epoch): print('epoch:', epoch + 1, '/', args.max_epoch) train(embeddings, loss, optimizer, data, args.samples_per_iter) lr_scheduler.step() save(embeddings, dictionary, args.result_file)

34.306452

96

0.665021

import argparse from pathlib import Path import itertools import math import numpy as np import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import (IterableDataset, RandomSampler, DataLoader) from gensim.corpora import Dictionary from tqdm import tqdm from torchemb.poincare_ball import PoincareBallEmbedding, PoincareBall parser = argparse.ArgumentParser('Poincare Embeddings') parser.add_argument('data_file', type=Path) parser.add_argument('result_file', type=Path) parser.add_argument('-e', '--embedding_dim', default=10, type=int) parser.add_argument('-m', '--max_epoch', default=200, type=int) parser.add_argument('-s', '--samples_per_iter', default=10000, type=int) parser.add_argument('-b', '--batch_size', default=512, type=int) parser.add_argument('-n', '--neg_size', default=10, type=int) parser.add_argument('-c', default=1, type=float) parser.add_argument('--lr', default=1.0e-3, type=float) parser.add_argument('--momentum', default=0.9, type=float) parser.add_argument('--seed', default=0, type=int) args = parser.parse_args() print(args) np.random.seed(args.seed) torch.manual_seed(args.seed) def load_data(data_file): data_file = Path(data_file) pairs = [] with data_file.open() as fin: for line in fin: a, b = line.strip().split('\t') pairs.append((a, b)) d = Dictionary(pairs) pairs = np.asarray([d.doc2idx(pair) for pair in pairs]) return d, pairs dictionary, pairs = load_data(args.data_file) print(len(dictionary), len(pairs)) class Dataset(IterableDataset): def __init__(self, pairs, neg_size): self.pairs = pairs self.neg_size = neg_size self.pair_sampler = RandomSampler(list(range(len(self.pairs))), replacement=True) def __iter__(self): pair_iter = itertools.cycle(iter(self.pair_sampler)) while True: idx = next(pair_iter) x, y = self.pairs[idx] ys = [y] + [self.pairs[next(pair_iter)][1] for _ in range(self.neg_size - 1)] yield x, torch.LongTensor(ys) data = DataLoader(Dataset(pairs, args.neg_size), batch_size=args.batch_size) embeddings = PoincareBallEmbedding(len(dictionary), args.embedding_dim, c=args.c) manifold = PoincareBall(c=args.c) loss = nn.CrossEntropyLoss() warmup_rate = 100 lr = args.lr * (args.batch_size ** 0.5) / (args.embedding_dim ** 0.5) optimizer = optim.Adam(embeddings.parameters(), lr=lr) lr_scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=math.exp(math.log(0.01) / args.max_epoch)) def train(embeddings, loss, optimizer, data, samples_per_iter): embeddings.train() data_iter = iter(data) avg_loss_ = 0 N = samples_per_iter // args.batch_size for i in tqdm(range(N)): idx1, idx2 = next(data_iter) x, ys = embeddings(idx1), embeddings(idx2) assert(not torch.any(torch.isnan(x))) assert(not torch.any(torch.isnan(ys))) ds = manifold.distance(x[:, None, :].expand_as(ys), ys) logits = -ds loss_ = loss(logits, torch.zeros(len(logits), dtype=torch.long)) optimizer.zero_grad() loss_.backward() optimizer.step() avg_loss_ += loss_.item() avg_loss_ /= N print('train loss: {:.5f}'.format(avg_loss_)) def save(embeddings, dictionary, result_file): embeddings.eval() result_file = Path(result_file) result_file.parent.mkdir(parents=True, exist_ok=True) with torch.no_grad(): with result_file.open('w') as fout: for i, c in sorted(dictionary.dfs.items()): e = embeddings(torch.LongTensor([i]))[0] print(dictionary[i], *[_.item() for _ in e], sep='\t', file=fout) for epoch in range(args.max_epoch): print('epoch:', epoch + 1, '/', args.max_epoch) train(embeddings, loss, optimizer, data, args.samples_per_iter) lr_scheduler.step() save(embeddings, dictionary, args.result_file)

true

f7132ceacb5dfc263c1fab22584dd1657361891e

1,945

py

Python

setup.py

gaohao95/boxtree

eb98de195d013d0fb44a51f54440e410c6a5f28e

[ "MIT" ]

null

setup.py

gaohao95/boxtree

eb98de195d013d0fb44a51f54440e410c6a5f28e

[ "MIT" ]

null

setup.py

gaohao95/boxtree

eb98de195d013d0fb44a51f54440e410c6a5f28e

[ "MIT" ]

null

#!/usr/bin/env python # -*- coding: utf-8 -*- def main(): from setuptools import setup version_dict = {} init_filename = "boxtree/version.py" exec(compile(open(init_filename, "r").read(), init_filename, "exec"), version_dict) setup(name="boxtree", version=version_dict["VERSION_TEXT"], description="Quadtree/octree building in Python and OpenCL", long_description=open("README.rst", "rt").read(), author="Andreas Kloeckner", author_email="inform@tiker.net", license="MIT", url="http://wiki.tiker.net/BoxTree", classifiers=[ 'Development Status :: 3 - Alpha', 'Intended Audience :: Developers', 'Intended Audience :: Other Audience', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: MIT License', 'Natural Language :: English', 'Programming Language :: Python', # We use conditional expressions, so 2.5 is the bare minimum. 'Programming Language :: Python :: 2.5', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', # 3.x has not yet been tested. 'Topic :: Scientific/Engineering', 'Topic :: Scientific/Engineering :: Information Analysis', 'Topic :: Scientific/Engineering :: Mathematics', 'Topic :: Scientific/Engineering :: Visualization', 'Topic :: Software Development :: Libraries', 'Topic :: Utilities', ], packages=["boxtree"], install_requires=[ "pytools>=2018.4", "pyopencl>=2018.2.2", "Mako>=0.7.3", "pytest>=2.3", "cgen>=2013.1.2", "six", ]) if __name__ == '__main__': main()

35.363636

75

0.524936

def main(): from setuptools import setup version_dict = {} init_filename = "boxtree/version.py" exec(compile(open(init_filename, "r").read(), init_filename, "exec"), version_dict) setup(name="boxtree", version=version_dict["VERSION_TEXT"], description="Quadtree/octree building in Python and OpenCL", long_description=open("README.rst", "rt").read(), author="Andreas Kloeckner", author_email="inform@tiker.net", license="MIT", url="http://wiki.tiker.net/BoxTree", classifiers=[ 'Development Status :: 3 - Alpha', 'Intended Audience :: Developers', 'Intended Audience :: Other Audience', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: MIT License', 'Natural Language :: English', 'Programming Language :: Python', 'Programming Language :: Python :: 2.5', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Topic :: Scientific/Engineering', 'Topic :: Scientific/Engineering :: Information Analysis', 'Topic :: Scientific/Engineering :: Mathematics', 'Topic :: Scientific/Engineering :: Visualization', 'Topic :: Software Development :: Libraries', 'Topic :: Utilities', ], packages=["boxtree"], install_requires=[ "pytools>=2018.4", "pyopencl>=2018.2.2", "Mako>=0.7.3", "pytest>=2.3", "cgen>=2013.1.2", "six", ]) if __name__ == '__main__': main()

true

f7132d45a987ba9b8b9c96fec4b274ea0d56ed63

10,668

py

Python

shamrock/full_node/coin_store.py

WarutaShinken/shamrock-blockchain

f457d5868f7cebfba08c63bd4a5b30c64d5400e2

[ "Apache-2.0" ]

3

2022-02-10T09:46:23.000Z

2022-03-22T17:10:50.000Z

shamrock/full_node/coin_store.py

WarutaShinken/shamrock-blockchain

f457d5868f7cebfba08c63bd4a5b30c64d5400e2

[ "Apache-2.0" ]

null

shamrock/full_node/coin_store.py

WarutaShinken/shamrock-blockchain

f457d5868f7cebfba08c63bd4a5b30c64d5400e2

[ "Apache-2.0" ]

null

from typing import List, Optional import aiosqlite from shamrock.types.blockchain_format.coin import Coin from shamrock.types.blockchain_format.sized_bytes import bytes32 from shamrock.types.coin_record import CoinRecord from shamrock.types.full_block import FullBlock from shamrock.util.db_wrapper import DBWrapper from shamrock.util.ints import uint32, uint64 from shamrock.util.lru_cache import LRUCache class CoinStore: """ This object handles CoinRecords in DB. A cache is maintained for quicker access to recent coins. """ coin_record_db: aiosqlite.Connection coin_record_cache: LRUCache cache_size: uint32 db_wrapper: DBWrapper @classmethod async def create(cls, db_wrapper: DBWrapper, cache_size: uint32 = uint32(60000)): self = cls() self.cache_size = cache_size self.db_wrapper = db_wrapper self.coin_record_db = db_wrapper.db await self.coin_record_db.execute("pragma journal_mode=wal") await self.coin_record_db.execute("pragma synchronous=2") await self.coin_record_db.execute( ( "CREATE TABLE IF NOT EXISTS coin_record(" "coin_name text PRIMARY KEY," " confirmed_index bigint," " spent_index bigint," " spent int," " coinbase int," " puzzle_hash text," " coin_parent text," " amount blob," " timestamp bigint)" ) ) # Useful for reorg lookups await self.coin_record_db.execute( "CREATE INDEX IF NOT EXISTS coin_confirmed_index on coin_record(confirmed_index)" ) await self.coin_record_db.execute("CREATE INDEX IF NOT EXISTS coin_spent_index on coin_record(spent_index)") await self.coin_record_db.execute("CREATE INDEX IF NOT EXISTS coin_spent on coin_record(spent)") await self.coin_record_db.execute("CREATE INDEX IF NOT EXISTS coin_puzzle_hash on coin_record(puzzle_hash)") await self.coin_record_db.commit() self.coin_record_cache = LRUCache(cache_size) return self async def new_block(self, block: FullBlock, tx_additions: List[Coin], tx_removals: List[bytes32]): """ Only called for blocks which are blocks (and thus have rewards and transactions) """ if block.is_transaction_block() is False: return None assert block.foliage_transaction_block is not None for coin in tx_additions: record: CoinRecord = CoinRecord( coin, block.height, uint32(0), False, False, block.foliage_transaction_block.timestamp, ) await self._add_coin_record(record, False) included_reward_coins = block.get_included_reward_coins() if block.height == 0: assert len(included_reward_coins) == 0 else: assert len(included_reward_coins) >= 2 for coin in included_reward_coins: reward_coin_r: CoinRecord = CoinRecord( coin, block.height, uint32(0), False, True, block.foliage_transaction_block.timestamp, ) await self._add_coin_record(reward_coin_r, False) total_amount_spent: int = 0 for coin_name in tx_removals: total_amount_spent += await self._set_spent(coin_name, block.height) # Sanity check, already checked in block_body_validation assert sum([a.amount for a in tx_additions]) <= total_amount_spent # Checks DB and DiffStores for CoinRecord with coin_name and returns it async def get_coin_record(self, coin_name: bytes32) -> Optional[CoinRecord]: cached = self.coin_record_cache.get(coin_name) if cached is not None: return cached cursor = await self.coin_record_db.execute("SELECT * from coin_record WHERE coin_name=?", (coin_name.hex(),)) row = await cursor.fetchone() await cursor.close() if row is not None: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) record = CoinRecord(coin, row[1], row[2], row[3], row[4], row[8]) self.coin_record_cache.put(record.coin.name(), record) return record return None async def get_coins_added_at_height(self, height: uint32) -> List[CoinRecord]: cursor = await self.coin_record_db.execute("SELECT * from coin_record WHERE confirmed_index=?", (height,)) rows = await cursor.fetchall() await cursor.close() coins = [] for row in rows: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coins.append(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])) return coins async def get_coins_removed_at_height(self, height: uint32) -> List[CoinRecord]: cursor = await self.coin_record_db.execute("SELECT * from coin_record WHERE spent_index=?", (height,)) rows = await cursor.fetchall() await cursor.close() coins = [] for row in rows: spent: bool = bool(row[3]) if spent: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coin_record = CoinRecord(coin, row[1], row[2], spent, row[4], row[8]) coins.append(coin_record) return coins # Checks DB and DiffStores for CoinRecords with puzzle_hash and returns them async def get_coin_records_by_puzzle_hash( self, include_spent_coins: bool, puzzle_hash: bytes32, start_height: uint32 = uint32(0), end_height: uint32 = uint32((2 ** 32) - 1), ) -> List[CoinRecord]: coins = set() cursor = await self.coin_record_db.execute( f"SELECT * from coin_record WHERE puzzle_hash=? AND confirmed_index>=? AND confirmed_index<? " f"{'' if include_spent_coins else 'AND spent=0'}", (puzzle_hash.hex(), start_height, end_height), ) rows = await cursor.fetchall() await cursor.close() for row in rows: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coins.add(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])) return list(coins) async def get_coin_records_by_puzzle_hashes( self, include_spent_coins: bool, puzzle_hashes: List[bytes32], start_height: uint32 = uint32(0), end_height: uint32 = uint32((2 ** 32) - 1), ) -> List[CoinRecord]: if len(puzzle_hashes) == 0: return [] coins = set() puzzle_hashes_db = tuple([ph.hex() for ph in puzzle_hashes]) cursor = await self.coin_record_db.execute( f'SELECT * from coin_record WHERE puzzle_hash in ({"?," * (len(puzzle_hashes_db) - 1)}?) ' f"AND confirmed_index>=? AND confirmed_index<? " f"{'' if include_spent_coins else 'AND spent=0'}", puzzle_hashes_db + (start_height, end_height), ) rows = await cursor.fetchall() await cursor.close() for row in rows: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coins.add(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])) return list(coins) async def rollback_to_block(self, block_index: int): """ Note that block_index can be negative, in which case everything is rolled back """ # Update memory cache delete_queue: bytes32 = [] for coin_name, coin_record in list(self.coin_record_cache.cache.items()): if int(coin_record.spent_block_index) > block_index: new_record = CoinRecord( coin_record.coin, coin_record.confirmed_block_index, uint32(0), False, coin_record.coinbase, coin_record.timestamp, ) self.coin_record_cache.put(coin_record.coin.name(), new_record) if int(coin_record.confirmed_block_index) > block_index: delete_queue.append(coin_name) for coin_name in delete_queue: self.coin_record_cache.remove(coin_name) # Delete from storage c1 = await self.coin_record_db.execute("DELETE FROM coin_record WHERE confirmed_index>?", (block_index,)) await c1.close() c2 = await self.coin_record_db.execute( "UPDATE coin_record SET spent_index = 0, spent = 0 WHERE spent_index>?", (block_index,), ) await c2.close() # Store CoinRecord in DB and ram cache async def _add_coin_record(self, record: CoinRecord, allow_replace: bool) -> None: if self.coin_record_cache.get(record.coin.name()) is not None: self.coin_record_cache.remove(record.coin.name()) cursor = await self.coin_record_db.execute( f"INSERT {'OR REPLACE ' if allow_replace else ''}INTO coin_record VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)", ( record.coin.name().hex(), record.confirmed_block_index, record.spent_block_index, int(record.spent), int(record.coinbase), str(record.coin.puzzle_hash.hex()), str(record.coin.parent_coin_info.hex()), bytes(record.coin.amount), record.timestamp, ), ) await cursor.close() # Update coin_record to be spent in DB async def _set_spent(self, coin_name: bytes32, index: uint32) -> uint64: current: Optional[CoinRecord] = await self.get_coin_record(coin_name) if current is None: raise ValueError(f"Cannot spend a coin that does not exist in db: {coin_name}") assert not current.spent # Redundant sanity check, already checked in block_body_validation spent: CoinRecord = CoinRecord( current.coin, current.confirmed_block_index, index, True, current.coinbase, current.timestamp, ) # type: ignore # noqa await self._add_coin_record(spent, True) return current.coin.amount

40.256604

118

0.61033

from typing import List, Optional import aiosqlite from shamrock.types.blockchain_format.coin import Coin from shamrock.types.blockchain_format.sized_bytes import bytes32 from shamrock.types.coin_record import CoinRecord from shamrock.types.full_block import FullBlock from shamrock.util.db_wrapper import DBWrapper from shamrock.util.ints import uint32, uint64 from shamrock.util.lru_cache import LRUCache class CoinStore: coin_record_db: aiosqlite.Connection coin_record_cache: LRUCache cache_size: uint32 db_wrapper: DBWrapper @classmethod async def create(cls, db_wrapper: DBWrapper, cache_size: uint32 = uint32(60000)): self = cls() self.cache_size = cache_size self.db_wrapper = db_wrapper self.coin_record_db = db_wrapper.db await self.coin_record_db.execute("pragma journal_mode=wal") await self.coin_record_db.execute("pragma synchronous=2") await self.coin_record_db.execute( ( "CREATE TABLE IF NOT EXISTS coin_record(" "coin_name text PRIMARY KEY," " confirmed_index bigint," " spent_index bigint," " spent int," " coinbase int," " puzzle_hash text," " coin_parent text," " amount blob," " timestamp bigint)" ) ) await self.coin_record_db.execute( "CREATE INDEX IF NOT EXISTS coin_confirmed_index on coin_record(confirmed_index)" ) await self.coin_record_db.execute("CREATE INDEX IF NOT EXISTS coin_spent_index on coin_record(spent_index)") await self.coin_record_db.execute("CREATE INDEX IF NOT EXISTS coin_spent on coin_record(spent)") await self.coin_record_db.execute("CREATE INDEX IF NOT EXISTS coin_puzzle_hash on coin_record(puzzle_hash)") await self.coin_record_db.commit() self.coin_record_cache = LRUCache(cache_size) return self async def new_block(self, block: FullBlock, tx_additions: List[Coin], tx_removals: List[bytes32]): if block.is_transaction_block() is False: return None assert block.foliage_transaction_block is not None for coin in tx_additions: record: CoinRecord = CoinRecord( coin, block.height, uint32(0), False, False, block.foliage_transaction_block.timestamp, ) await self._add_coin_record(record, False) included_reward_coins = block.get_included_reward_coins() if block.height == 0: assert len(included_reward_coins) == 0 else: assert len(included_reward_coins) >= 2 for coin in included_reward_coins: reward_coin_r: CoinRecord = CoinRecord( coin, block.height, uint32(0), False, True, block.foliage_transaction_block.timestamp, ) await self._add_coin_record(reward_coin_r, False) total_amount_spent: int = 0 for coin_name in tx_removals: total_amount_spent += await self._set_spent(coin_name, block.height) assert sum([a.amount for a in tx_additions]) <= total_amount_spent async def get_coin_record(self, coin_name: bytes32) -> Optional[CoinRecord]: cached = self.coin_record_cache.get(coin_name) if cached is not None: return cached cursor = await self.coin_record_db.execute("SELECT * from coin_record WHERE coin_name=?", (coin_name.hex(),)) row = await cursor.fetchone() await cursor.close() if row is not None: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) record = CoinRecord(coin, row[1], row[2], row[3], row[4], row[8]) self.coin_record_cache.put(record.coin.name(), record) return record return None async def get_coins_added_at_height(self, height: uint32) -> List[CoinRecord]: cursor = await self.coin_record_db.execute("SELECT * from coin_record WHERE confirmed_index=?", (height,)) rows = await cursor.fetchall() await cursor.close() coins = [] for row in rows: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coins.append(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])) return coins async def get_coins_removed_at_height(self, height: uint32) -> List[CoinRecord]: cursor = await self.coin_record_db.execute("SELECT * from coin_record WHERE spent_index=?", (height,)) rows = await cursor.fetchall() await cursor.close() coins = [] for row in rows: spent: bool = bool(row[3]) if spent: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coin_record = CoinRecord(coin, row[1], row[2], spent, row[4], row[8]) coins.append(coin_record) return coins async def get_coin_records_by_puzzle_hash( self, include_spent_coins: bool, puzzle_hash: bytes32, start_height: uint32 = uint32(0), end_height: uint32 = uint32((2 ** 32) - 1), ) -> List[CoinRecord]: coins = set() cursor = await self.coin_record_db.execute( f"SELECT * from coin_record WHERE puzzle_hash=? AND confirmed_index>=? AND confirmed_index<? " f"{'' if include_spent_coins else 'AND spent=0'}", (puzzle_hash.hex(), start_height, end_height), ) rows = await cursor.fetchall() await cursor.close() for row in rows: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coins.add(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])) return list(coins) async def get_coin_records_by_puzzle_hashes( self, include_spent_coins: bool, puzzle_hashes: List[bytes32], start_height: uint32 = uint32(0), end_height: uint32 = uint32((2 ** 32) - 1), ) -> List[CoinRecord]: if len(puzzle_hashes) == 0: return [] coins = set() puzzle_hashes_db = tuple([ph.hex() for ph in puzzle_hashes]) cursor = await self.coin_record_db.execute( f'SELECT * from coin_record WHERE puzzle_hash in ({"?," * (len(puzzle_hashes_db) - 1)}?) ' f"AND confirmed_index>=? AND confirmed_index<? " f"{'' if include_spent_coins else 'AND spent=0'}", puzzle_hashes_db + (start_height, end_height), ) rows = await cursor.fetchall() await cursor.close() for row in rows: coin = Coin(bytes32(bytes.fromhex(row[6])), bytes32(bytes.fromhex(row[5])), uint64.from_bytes(row[7])) coins.add(CoinRecord(coin, row[1], row[2], row[3], row[4], row[8])) return list(coins) async def rollback_to_block(self, block_index: int): delete_queue: bytes32 = [] for coin_name, coin_record in list(self.coin_record_cache.cache.items()): if int(coin_record.spent_block_index) > block_index: new_record = CoinRecord( coin_record.coin, coin_record.confirmed_block_index, uint32(0), False, coin_record.coinbase, coin_record.timestamp, ) self.coin_record_cache.put(coin_record.coin.name(), new_record) if int(coin_record.confirmed_block_index) > block_index: delete_queue.append(coin_name) for coin_name in delete_queue: self.coin_record_cache.remove(coin_name) c1 = await self.coin_record_db.execute("DELETE FROM coin_record WHERE confirmed_index>?", (block_index,)) await c1.close() c2 = await self.coin_record_db.execute( "UPDATE coin_record SET spent_index = 0, spent = 0 WHERE spent_index>?", (block_index,), ) await c2.close() async def _add_coin_record(self, record: CoinRecord, allow_replace: bool) -> None: if self.coin_record_cache.get(record.coin.name()) is not None: self.coin_record_cache.remove(record.coin.name()) cursor = await self.coin_record_db.execute( f"INSERT {'OR REPLACE ' if allow_replace else ''}INTO coin_record VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)", ( record.coin.name().hex(), record.confirmed_block_index, record.spent_block_index, int(record.spent), int(record.coinbase), str(record.coin.puzzle_hash.hex()), str(record.coin.parent_coin_info.hex()), bytes(record.coin.amount), record.timestamp, ), ) await cursor.close() async def _set_spent(self, coin_name: bytes32, index: uint32) -> uint64: current: Optional[CoinRecord] = await self.get_coin_record(coin_name) if current is None: raise ValueError(f"Cannot spend a coin that does not exist in db: {coin_name}") assert not current.spent spent: CoinRecord = CoinRecord( current.coin, current.confirmed_block_index, index, True, current.coinbase, current.timestamp, ) await self._add_coin_record(spent, True) return current.coin.amount

true

f7132de250a1f4a5553418e21c992ffefe85e308

2,512

py

Python

app.py

kbots-dga/ml_classificator

0163141de7389825787b9813019582be98d0f266

[ "MIT" ]

null

app.py

kbots-dga/ml_classificator

0163141de7389825787b9813019582be98d0f266

[ "MIT" ]

null

app.py

kbots-dga/ml_classificator

0163141de7389825787b9813019582be98d0f266

[ "MIT" ]

null

import streamlit as st import plotly.express as px import pandas as pd import pickle import os import base64 from io import BytesIO from datetime import datetime def to_excel(df): output = BytesIO() writer = pd.ExcelWriter(output, engine='xlsxwriter') df.to_excel(writer, index=False, sheet_name='Sheet1') writer.save() processed_data = output.getvalue() return processed_data def get_table_download_link(df): val = to_excel(df) b64 = base64.b64encode(val) date_now = datetime.utcnow() file_name = f'data_resultado-{date_now.strftime("%Y%m%d%H%M%S")}.xlsx' link_download = f""" <a href="data:application/octet-stream;base64,{b64.decode()}" download="{file_name}">Download xlsx file</a> """ return link_download def plot_graph(df_graph): fig = px.bar( df_graph, x='Labels', y='Descrição', # text='Text test', title='Test', labels={ "Labels": "Labels", "Descrição": 'Número de coisas' }, # width=1400, height=500 ) return fig def main(classificador): st.title('Model') process_file = st.file_uploader( "Faça o upload do arquivo no campo abaixo.", type=["csv", "xlsx"], accept_multiple_files=False ) print(process_file) print(os.environ.get('TOKEN')) if process_file != None: if process_file.name.endswith('.csv'): df = pd.read_csv( process_file, header=0, skip_blank_lines=True, skipinitialspace=True, encoding='latin-1') elif process_file.name.endswith('.xlsx'): df = pd.read_excel( process_file, engine="openpyxl") with st.empty(): st.write('Fazendo as predições ...') df['Labels'] = classificador.predict( df["Descrição"].astype("unicode")) st.write('Predições feitas com sucesso !!!') st.dataframe(df.head(20)) df_graph = df.groupby(['Labels'], as_index=False)['Descrição'].count() df_graph.sort_values(by=['Descrição'], inplace=True, ascending=False) print(df_graph) st.plotly_chart(plot_graph(df_graph), use_container_width=True) st.text('Gerando link para download ...') st.markdown(get_table_download_link(df), unsafe_allow_html=True) st.success('Link gerado com sucesso.') if __name__ == '__main__': classificador = pickle.load(open("modelo_final.pkl", "rb")) main(classificador)

29.552941

136

0.624602

import streamlit as st import plotly.express as px import pandas as pd import pickle import os import base64 from io import BytesIO from datetime import datetime def to_excel(df): output = BytesIO() writer = pd.ExcelWriter(output, engine='xlsxwriter') df.to_excel(writer, index=False, sheet_name='Sheet1') writer.save() processed_data = output.getvalue() return processed_data def get_table_download_link(df): val = to_excel(df) b64 = base64.b64encode(val) date_now = datetime.utcnow() file_name = f'data_resultado-{date_now.strftime("%Y%m%d%H%M%S")}.xlsx' link_download = f""" <a href="data:application/octet-stream;base64,{b64.decode()}" download="{file_name}">Download xlsx file</a> """ return link_download def plot_graph(df_graph): fig = px.bar( df_graph, x='Labels', y='Descrição', title='Test', labels={ "Labels": "Labels", "Descrição": 'Número de coisas' }, height=500 ) return fig def main(classificador): st.title('Model') process_file = st.file_uploader( "Faça o upload do arquivo no campo abaixo.", type=["csv", "xlsx"], accept_multiple_files=False ) print(process_file) print(os.environ.get('TOKEN')) if process_file != None: if process_file.name.endswith('.csv'): df = pd.read_csv( process_file, header=0, skip_blank_lines=True, skipinitialspace=True, encoding='latin-1') elif process_file.name.endswith('.xlsx'): df = pd.read_excel( process_file, engine="openpyxl") with st.empty(): st.write('Fazendo as predições ...') df['Labels'] = classificador.predict( df["Descrição"].astype("unicode")) st.write('Predições feitas com sucesso !!!') st.dataframe(df.head(20)) df_graph = df.groupby(['Labels'], as_index=False)['Descrição'].count() df_graph.sort_values(by=['Descrição'], inplace=True, ascending=False) print(df_graph) st.plotly_chart(plot_graph(df_graph), use_container_width=True) st.text('Gerando link para download ...') st.markdown(get_table_download_link(df), unsafe_allow_html=True) st.success('Link gerado com sucesso.') if __name__ == '__main__': classificador = pickle.load(open("modelo_final.pkl", "rb")) main(classificador)

true

f7132e458a9d4d5d360b91406043e6027eff5c5e

6,334

py

Python

frameworks/cassandra/tests/test_toggle_tls.py

ankitcid/dcos-commons

6804670110a9db01a7414f1c2abc2a35d9d7433d

[ "Apache-2.0" ]

201

2016-06-02T21:07:21.000Z

2021-03-31T06:15:37.000Z

frameworks/cassandra/tests/test_toggle_tls.py

ankitcid/dcos-commons

6804670110a9db01a7414f1c2abc2a35d9d7433d

[ "Apache-2.0" ]

1,679

2016-06-06T17:32:26.000Z

2021-04-30T20:44:30.000Z

frameworks/cassandra/tests/test_toggle_tls.py

ankitcid/dcos-commons

6804670110a9db01a7414f1c2abc2a35d9d7433d

[ "Apache-2.0" ]

231

2016-06-09T21:40:22.000Z

2022-02-14T13:41:44.000Z

import json import logging import pytest import tempfile from typing import Any, Dict, Iterator, Optional import sdk_cmd import sdk_install import sdk_jobs import sdk_plan import sdk_utils from security import transport_encryption from tests import config log = logging.getLogger(__name__) @pytest.fixture(scope="module") def service_account(configure_security: None) -> Iterator[Dict[str, Any]]: """ Sets up a service account for use with TLS. """ try: name = config.SERVICE_NAME service_account_info = transport_encryption.setup_service_account(name) yield service_account_info finally: transport_encryption.cleanup_service_account(config.SERVICE_NAME, service_account_info) @pytest.fixture(scope="module") def dcos_ca_bundle() -> str: """ Retrieve DC/OS CA bundle and returns the content. """ return transport_encryption.fetch_dcos_ca_bundle_contents().decode("ascii") @pytest.fixture(scope="module", autouse=True) def cassandra_service(service_account: Dict[str, Any]) -> Iterator[Dict[str, Any]]: """ A pytest fixture that installs the cassandra service. On teardown, the service is uninstalled. """ options = { "service": { "name": config.SERVICE_NAME, # Note that since we wish to toggle TLS which *REQUIRES* a service account, # we need to install Cassandra with a service account to start with. "service_account": service_account["name"], "service_account_secret": service_account["secret"], } } sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME) try: sdk_install.install( config.PACKAGE_NAME, config.SERVICE_NAME, config.DEFAULT_TASK_COUNT, additional_options=options, wait_for_deployment=True, ) yield {**options, **{"package_name": config.PACKAGE_NAME}} finally: sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME) @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_default_installation(cassandra_service: Dict[str, Any]) -> None: """ Tests writing, reading and deleting data over a plaintext connection. """ verify_client_can_write_read_and_delete() @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_enable_tls_and_plaintext( cassandra_service: Dict[str, Any], dcos_ca_bundle: str, ) -> None: """ Tests writing, reading and deleting data over TLS but still accepting plaintext connections. """ update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=True) verify_client_can_write_read_and_delete(dcos_ca_bundle) @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_disable_plaintext( cassandra_service: Dict[str, Any], dcos_ca_bundle: str, ) -> None: """ Tests writing, reading and deleting data over a TLS connection. """ update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=False) verify_client_can_write_read_and_delete(dcos_ca_bundle) @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_disable_tls(cassandra_service: Dict[str, Any]) -> None: """ Tests writing, reading and deleting data over a plaintext connection. """ update_service_transport_encryption(cassandra_service, enabled=False, allow_plaintext=False) verify_client_can_write_read_and_delete() @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_enabling_then_disabling_tls( cassandra_service: Dict[str, Any], dcos_ca_bundle: str, ) -> None: # Write data. write_data_job = config.get_write_data_job() with sdk_jobs.InstallJobContext([write_data_job]): sdk_jobs.run_job(write_data_job) # Turn TLS on and off again. update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=True) update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=False) update_service_transport_encryption(cassandra_service, enabled=False, allow_plaintext=False) # Make sure data is still there. verify_data_job = config.get_verify_data_job() with sdk_jobs.InstallJobContext([verify_data_job]): sdk_jobs.run_job(verify_data_job) def verify_client_can_write_read_and_delete( dcos_ca_bundle: Optional[str] = None, ) -> None: write_data_job = config.get_write_data_job(dcos_ca_bundle=dcos_ca_bundle) verify_data_job = config.get_verify_data_job(dcos_ca_bundle=dcos_ca_bundle) delete_data_job = config.get_delete_data_job(dcos_ca_bundle=dcos_ca_bundle) verify_deletion_job = config.get_verify_deletion_job(dcos_ca_bundle=dcos_ca_bundle) with sdk_jobs.InstallJobContext( [write_data_job, verify_data_job, delete_data_job, verify_deletion_job] ): sdk_jobs.run_job(write_data_job) sdk_jobs.run_job(verify_data_job) sdk_jobs.run_job(delete_data_job) sdk_jobs.run_job(verify_deletion_job) def update_service_transport_encryption( cassandra_service: Dict[str, Any], enabled: bool = False, allow_plaintext: bool = False ) -> None: update_options = { "service": { "security": { "transport_encryption": {"enabled": enabled, "allow_plaintext": allow_plaintext} } } } update_service(cassandra_service, update_options) def update_service(service: Dict[str, Any], options: Dict[str, Any]) -> None: with tempfile.NamedTemporaryFile("w", suffix=".json") as f: options_path = f.name log.info("Writing updated options to %s", options_path) json.dump(options, f) f.flush() cmd = ["update", "start", "--options={}".format(options_path)] sdk_cmd.svc_cli(service["package_name"], service["service"]["name"], " ".join(cmd)) # An update plan is a deploy plan sdk_plan.wait_for_kicked_off_deployment(service["service"]["name"]) sdk_plan.wait_for_completed_deployment(service["service"]["name"])

31.829146

96

0.72324

import json import logging import pytest import tempfile from typing import Any, Dict, Iterator, Optional import sdk_cmd import sdk_install import sdk_jobs import sdk_plan import sdk_utils from security import transport_encryption from tests import config log = logging.getLogger(__name__) @pytest.fixture(scope="module") def service_account(configure_security: None) -> Iterator[Dict[str, Any]]: try: name = config.SERVICE_NAME service_account_info = transport_encryption.setup_service_account(name) yield service_account_info finally: transport_encryption.cleanup_service_account(config.SERVICE_NAME, service_account_info) @pytest.fixture(scope="module") def dcos_ca_bundle() -> str: return transport_encryption.fetch_dcos_ca_bundle_contents().decode("ascii") @pytest.fixture(scope="module", autouse=True) def cassandra_service(service_account: Dict[str, Any]) -> Iterator[Dict[str, Any]]: options = { "service": { "name": config.SERVICE_NAME, "service_account": service_account["name"], "service_account_secret": service_account["secret"], } } sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME) try: sdk_install.install( config.PACKAGE_NAME, config.SERVICE_NAME, config.DEFAULT_TASK_COUNT, additional_options=options, wait_for_deployment=True, ) yield {**options, **{"package_name": config.PACKAGE_NAME}} finally: sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME) @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_default_installation(cassandra_service: Dict[str, Any]) -> None: verify_client_can_write_read_and_delete() @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_enable_tls_and_plaintext( cassandra_service: Dict[str, Any], dcos_ca_bundle: str, ) -> None: update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=True) verify_client_can_write_read_and_delete(dcos_ca_bundle) @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_disable_plaintext( cassandra_service: Dict[str, Any], dcos_ca_bundle: str, ) -> None: update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=False) verify_client_can_write_read_and_delete(dcos_ca_bundle) @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_disable_tls(cassandra_service: Dict[str, Any]) -> None: update_service_transport_encryption(cassandra_service, enabled=False, allow_plaintext=False) verify_client_can_write_read_and_delete() @pytest.mark.sanity @pytest.mark.tls @pytest.mark.dcos_min_version("1.10") @sdk_utils.dcos_ee_only def test_enabling_then_disabling_tls( cassandra_service: Dict[str, Any], dcos_ca_bundle: str, ) -> None: write_data_job = config.get_write_data_job() with sdk_jobs.InstallJobContext([write_data_job]): sdk_jobs.run_job(write_data_job) update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=True) update_service_transport_encryption(cassandra_service, enabled=True, allow_plaintext=False) update_service_transport_encryption(cassandra_service, enabled=False, allow_plaintext=False) verify_data_job = config.get_verify_data_job() with sdk_jobs.InstallJobContext([verify_data_job]): sdk_jobs.run_job(verify_data_job) def verify_client_can_write_read_and_delete( dcos_ca_bundle: Optional[str] = None, ) -> None: write_data_job = config.get_write_data_job(dcos_ca_bundle=dcos_ca_bundle) verify_data_job = config.get_verify_data_job(dcos_ca_bundle=dcos_ca_bundle) delete_data_job = config.get_delete_data_job(dcos_ca_bundle=dcos_ca_bundle) verify_deletion_job = config.get_verify_deletion_job(dcos_ca_bundle=dcos_ca_bundle) with sdk_jobs.InstallJobContext( [write_data_job, verify_data_job, delete_data_job, verify_deletion_job] ): sdk_jobs.run_job(write_data_job) sdk_jobs.run_job(verify_data_job) sdk_jobs.run_job(delete_data_job) sdk_jobs.run_job(verify_deletion_job) def update_service_transport_encryption( cassandra_service: Dict[str, Any], enabled: bool = False, allow_plaintext: bool = False ) -> None: update_options = { "service": { "security": { "transport_encryption": {"enabled": enabled, "allow_plaintext": allow_plaintext} } } } update_service(cassandra_service, update_options) def update_service(service: Dict[str, Any], options: Dict[str, Any]) -> None: with tempfile.NamedTemporaryFile("w", suffix=".json") as f: options_path = f.name log.info("Writing updated options to %s", options_path) json.dump(options, f) f.flush() cmd = ["update", "start", "--options={}".format(options_path)] sdk_cmd.svc_cli(service["package_name"], service["service"]["name"], " ".join(cmd)) sdk_plan.wait_for_kicked_off_deployment(service["service"]["name"]) sdk_plan.wait_for_completed_deployment(service["service"]["name"])

true

f7132e9e350404c280534cd2d05734b0b318e638

1,068

py

Python

Python/FrequencyQueries.py

theolamide/Whiteboard

46f31bdea99cacedf32e817cc281ce46be7993b1

[ "MIT" ]

1

2021-12-22T08:05:07.000Z

Python/FrequencyQueries.py

theolamide/Whiteboard

46f31bdea99cacedf32e817cc281ce46be7993b1

[ "MIT" ]

null

Python/FrequencyQueries.py

theolamide/Whiteboard

46f31bdea99cacedf32e817cc281ce46be7993b1

[ "MIT" ]

1

2021-12-22T08:05:01.000Z

def frequencyQueries(queries): collection = {} cumOperationThree = [] for i in range(0, len(queries)): operation = queries[i][0] numToAdd = queries[i][1] if operation == 1: if numToAdd in collection.keys(): collection[numToAdd] += 1 else: collection[numToAdd] = 1 # print(collection) elif operation == 2: if numToAdd in collection.keys() and collection[numToAdd] > 0: collection[numToAdd] -= 1 # print(collection) elif operation == 3: found = False for key in collection: if numToAdd == collection[key]: cumOperationThree.append(1) found = True break if not found: cumOperationThree.append(0) print(cumOperationThree) return cumOperationThree Query = [[1, 3], [2, 3], [3, 2], [1, 4], [1, 5], [1, 5], [1, 4], [3, 2], [2, 4], [3, 2]] frequencyQueries(Query)

28.105263

74

0.495318

def frequencyQueries(queries): collection = {} cumOperationThree = [] for i in range(0, len(queries)): operation = queries[i][0] numToAdd = queries[i][1] if operation == 1: if numToAdd in collection.keys(): collection[numToAdd] += 1 else: collection[numToAdd] = 1 elif operation == 2: if numToAdd in collection.keys() and collection[numToAdd] > 0: collection[numToAdd] -= 1 elif operation == 3: found = False for key in collection: if numToAdd == collection[key]: cumOperationThree.append(1) found = True break if not found: cumOperationThree.append(0) print(cumOperationThree) return cumOperationThree Query = [[1, 3], [2, 3], [3, 2], [1, 4], [1, 5], [1, 5], [1, 4], [3, 2], [2, 4], [3, 2]] frequencyQueries(Query)

true

f7132ed83fc85ba948e63176cacdb8b29b6e17be

10,954

py

Python

src/physlearn/apis/data.py

yyLabPhysAI/PhysioLearn

673057a15397d7defaf55afd6e657418c314bf29

[ "MIT" ]

null

src/physlearn/apis/data.py

yyLabPhysAI/PhysioLearn

673057a15397d7defaf55afd6e657418c314bf29

[ "MIT" ]

null

src/physlearn/apis/data.py

yyLabPhysAI/PhysioLearn

673057a15397d7defaf55afd6e657418c314bf29

[ "MIT" ]

null

from datetime import timedelta from typing import Any, Dict, Optional, Sequence from physlearn.names import DataBaseName, LabelType, NonSignalDataType, SignalType from physlearn.typing import Array class Signal: """A signal base class. Args: start_time: The time from the beginning of the record until the beginning of the signal. end_time: The time from the beginning of the record until the beginning of the signal. time_axis: A tensor with the time axis of the signal, shape: [1, time steps]. signal: The signal tensor of shape [channels, time steps]. signal_type: What kind of signal is it? channel_names: sequence of channel names in the signal. For example: names of different EEG electrodes. """ def __init__( self, start_time: timedelta, end_time: timedelta, time_axis: Array, signal: Array, signal_type: SignalType, channel_names: Optional[Sequence[str]] = None, ): """ Args: start_time: The time from the beginning of the record until the beginning of the signal. end_time: The time from the beginning of the record until the beginning of the signal. time_axis: A tensor with the time axis of the signal, with shape: [1, time steps]. signal: The signal tensor of shape [channels, time steps]. signal_type: What kind of signal is it? channel_names: Names of the channels in the signal. For example: names of different EEG electrodes. """ self._start_time = start_time self._end_time = end_time self._time_axis = time_axis self._signal = signal self._signal_type = signal_type self._channel_names = channel_names self._num_channels = self.get_num_channels() self.check_dimensions() self.check_times() self._check_num_channels() def __getitem__(self, idx): """ Syntactic sugar, allows getting data from a Signal object like: >>> signal[1:2, :1000] """ return self.signal[idx].copy() @property def start_time(self): """ """ return self._start_time @property def end_time(self): """ """ return self._end_time @property def time_axis(self): """ """ return self._time_axis.copy() @property def signal(self): """ """ return self._signal.copy() @property def signal_type(self): """ """ return self._signal_type @property def channel_names(self): """ """ return self._channel_names @property def num_channels(self): """ Number of channels in the signal. """ return self._num_channels def get_num_channels(self): return self.signal.shape[0] def check_dimensions(self): """Signals can either be of the same length as the time axis or empty""" if not self.signal.size: return elif self.signal.shape[1] == self.time_axis.shape[1]: return else: raise ValueError( "Illegal signal dimensions, the signal has to be of the " "same length as the time axis or empty" ) def check_times(self): """End time greater then start time""" if self.end_time <= self.start_time: raise ValueError("End time can't be before or same as start time") def __eq__(self, other): return bool( self.start_time == other.start_time and self.end_time == other.end_time and (self.time_axis == other.time_axis).all() and (self.signal == other.signal).all() and self.signal_type == other.signal_type ) def _check_num_channels(self): """ Checks number of channel match channel names """ if self.channel_names: if self.num_channels != len(self.channel_names): raise ValueError("Number of channels mismatch channel names") def find_channel(self, desired_channel_name: str): """ Search for a given channel name in the signal's channel names. Raises a value error if the channel was not found Returns the index of the given channel in the list of channel names of the signal. """ if desired_channel_name not in self.channel_names: raise ValueError( f"Channel {desired_channel_name} not found" f"in channel names" ) else: return tuple( i for i, e in enumerate(self.channel_names) if e == desired_channel_name ) def signal_like_this( self, start_time: timedelta = None, end_time: timedelta = None, time_axis: Array = None, signal: Array = None, signal_type: SignalType = None, channel_names: Optional[Sequence[str]] = None, ): if not type(self) == Signal: raise NotImplementedError("Inheriting classes should override this method") start_time = start_time if start_time else self.start_time end_time = end_time if end_time else self.end_time time_axis = time_axis if time_axis is not None else self.time_axis signal = signal if signal is not None else self.signal signal_type = signal_type if signal_type else self.signal_type channel_names = channel_names if channel_names else self.channel_names return Signal( start_time=start_time, end_time=end_time, time_axis=time_axis, signal=signal, signal_type=signal_type, channel_names=channel_names, ) class Sample: """ A single sample from a single patient from a single database. May include a full or a partial recording. """ def __init__( self, db: DataBaseName, db_version: str, patient_id: int, record_id: int, sample_id: int, signals: Dict[SignalType, Signal], data: Dict[NonSignalDataType, Array], metadata: Dict[NonSignalDataType, Any], label: Dict[LabelType, Array], ): """ Args: db: Name of the database the sample is taken from db_version: Version of the database the sample is taken from patient_id: ID of the patient the sample is taken from in the database record_id: ID of the record within the patient sample_id: ID of the sample within the record signals: Signal data of the sample as a dictionary with the structure: signals = { signal_type1: signal1, signal_type2: signal2, ... } data: Non-signal data as tensors (clinical, socioeconomic, etc.) metadata: Non-signal data (clinical, socioeconomic, etc.) label: The label of the sample for a specific supervised learning task Note: `data` and `metadata` may look alike but they are used for completely different purposes. `data` contains tensors, ready to be used as features for ML models while `metadata` is unstructured and used for internal operations of the system like labeling. """ self._db = db self._db_version = db_version self._patient_id = patient_id self._record_id = record_id self._sample_id = sample_id self._signals = signals self._data = data self._metadata = metadata self._label = label @property def record_id(self): return self._record_id def sample_like_this( self, db: Optional[DataBaseName] = None, db_version: Optional[str] = None, patient_id: Optional[int] = None, sample_id: Optional[int] = None, signals: Optional[Dict[SignalType, Signal]] = None, data: Optional[Dict[NonSignalDataType, Array]] = None, metadata: Optional[Dict[NonSignalDataType, Any]] = None, label: Optional[Dict[LabelType, Array]] = None, record_id: Optional[int] = None, **kwargs, ): if not type(self) == Sample: raise NotImplementedError("Inheriting classes should override this method") db = db if db else self.db db_version = db_version if db_version else self.db_version patient_id = patient_id if patient_id else self.patient_id sample_id = sample_id if sample_id else self.sample_id signals = signals if signals else self.signals data = data if data else self.data metadata = metadata if metadata else self.metadata label = label if label else self.label record_id = record_id if record_id else self.record_id return Sample( db=db, db_version=db_version, patient_id=patient_id, record_id=record_id, sample_id=sample_id, signals=signals, data=data, metadata=metadata, label=label, ) @property def db(self): """ """ return self._db @property def db_version(self): """ """ return self._db_version @property def patient_id(self): """ """ return self._patient_id @property def sample_id(self): """ """ return self._sample_id @property def signals(self): """ """ return self._signals @property def data(self): """ """ return self._data @property def metadata(self): """ """ return self._metadata @property def label(self): """ """ return self._label def __eq__(self, other): return all( [ self.db == other.db, self.db_version == other.db_version, self.patient_id == other.patient_id, self.record_id == other.record_id, self.sample_id == other.sample_id, self.signals == other.signals, compare_tensor_dict(self.data, other.data), compare_tensor_dict(self.label, other.label), ] ) def compare_tensor_dict(d1: Dict[Any, Array], d2: Dict[Any, Array]): """Compare two dictionaries of tensors Args: d1: First dictionary d2: Second dictionary Returns: True if same, false otherwise. """ if not d1 and not d2: return True return ( all([(t1 == t2).all() for t1, t2 in zip(d1.values(), d2.values())]) and d1.keys() == d2.keys() )

31.297143

88

0.588643

from datetime import timedelta from typing import Any, Dict, Optional, Sequence from physlearn.names import DataBaseName, LabelType, NonSignalDataType, SignalType from physlearn.typing import Array class Signal: def __init__( self, start_time: timedelta, end_time: timedelta, time_axis: Array, signal: Array, signal_type: SignalType, channel_names: Optional[Sequence[str]] = None, ): self._start_time = start_time self._end_time = end_time self._time_axis = time_axis self._signal = signal self._signal_type = signal_type self._channel_names = channel_names self._num_channels = self.get_num_channels() self.check_dimensions() self.check_times() self._check_num_channels() def __getitem__(self, idx): return self.signal[idx].copy() @property def start_time(self): return self._start_time @property def end_time(self): return self._end_time @property def time_axis(self): return self._time_axis.copy() @property def signal(self): return self._signal.copy() @property def signal_type(self): return self._signal_type @property def channel_names(self): return self._channel_names @property def num_channels(self): return self._num_channels def get_num_channels(self): return self.signal.shape[0] def check_dimensions(self): if not self.signal.size: return elif self.signal.shape[1] == self.time_axis.shape[1]: return else: raise ValueError( "Illegal signal dimensions, the signal has to be of the " "same length as the time axis or empty" ) def check_times(self): if self.end_time <= self.start_time: raise ValueError("End time can't be before or same as start time") def __eq__(self, other): return bool( self.start_time == other.start_time and self.end_time == other.end_time and (self.time_axis == other.time_axis).all() and (self.signal == other.signal).all() and self.signal_type == other.signal_type ) def _check_num_channels(self): if self.channel_names: if self.num_channels != len(self.channel_names): raise ValueError("Number of channels mismatch channel names") def find_channel(self, desired_channel_name: str): if desired_channel_name not in self.channel_names: raise ValueError( f"Channel {desired_channel_name} not found" f"in channel names" ) else: return tuple( i for i, e in enumerate(self.channel_names) if e == desired_channel_name ) def signal_like_this( self, start_time: timedelta = None, end_time: timedelta = None, time_axis: Array = None, signal: Array = None, signal_type: SignalType = None, channel_names: Optional[Sequence[str]] = None, ): if not type(self) == Signal: raise NotImplementedError("Inheriting classes should override this method") start_time = start_time if start_time else self.start_time end_time = end_time if end_time else self.end_time time_axis = time_axis if time_axis is not None else self.time_axis signal = signal if signal is not None else self.signal signal_type = signal_type if signal_type else self.signal_type channel_names = channel_names if channel_names else self.channel_names return Signal( start_time=start_time, end_time=end_time, time_axis=time_axis, signal=signal, signal_type=signal_type, channel_names=channel_names, ) class Sample: def __init__( self, db: DataBaseName, db_version: str, patient_id: int, record_id: int, sample_id: int, signals: Dict[SignalType, Signal], data: Dict[NonSignalDataType, Array], metadata: Dict[NonSignalDataType, Any], label: Dict[LabelType, Array], ): self._db = db self._db_version = db_version self._patient_id = patient_id self._record_id = record_id self._sample_id = sample_id self._signals = signals self._data = data self._metadata = metadata self._label = label @property def record_id(self): return self._record_id def sample_like_this( self, db: Optional[DataBaseName] = None, db_version: Optional[str] = None, patient_id: Optional[int] = None, sample_id: Optional[int] = None, signals: Optional[Dict[SignalType, Signal]] = None, data: Optional[Dict[NonSignalDataType, Array]] = None, metadata: Optional[Dict[NonSignalDataType, Any]] = None, label: Optional[Dict[LabelType, Array]] = None, record_id: Optional[int] = None, **kwargs, ): if not type(self) == Sample: raise NotImplementedError("Inheriting classes should override this method") db = db if db else self.db db_version = db_version if db_version else self.db_version patient_id = patient_id if patient_id else self.patient_id sample_id = sample_id if sample_id else self.sample_id signals = signals if signals else self.signals data = data if data else self.data metadata = metadata if metadata else self.metadata label = label if label else self.label record_id = record_id if record_id else self.record_id return Sample( db=db, db_version=db_version, patient_id=patient_id, record_id=record_id, sample_id=sample_id, signals=signals, data=data, metadata=metadata, label=label, ) @property def db(self): return self._db @property def db_version(self): return self._db_version @property def patient_id(self): return self._patient_id @property def sample_id(self): return self._sample_id @property def signals(self): return self._signals @property def data(self): return self._data @property def metadata(self): return self._metadata @property def label(self): return self._label def __eq__(self, other): return all( [ self.db == other.db, self.db_version == other.db_version, self.patient_id == other.patient_id, self.record_id == other.record_id, self.sample_id == other.sample_id, self.signals == other.signals, compare_tensor_dict(self.data, other.data), compare_tensor_dict(self.label, other.label), ] ) def compare_tensor_dict(d1: Dict[Any, Array], d2: Dict[Any, Array]): if not d1 and not d2: return True return ( all([(t1 == t2).all() for t1, t2 in zip(d1.values(), d2.values())]) and d1.keys() == d2.keys() )

true

f7132fcc5154c094edb08528aee9897931ed3af6

4,167

py

Python

legacy/legacy_scripts/legacy/.ipynb_checkpoints/train_and_predict-checkpoint.py

tomkimpson/ML4L

ffa8360cb80df25bd6af4fa5cc39b42bd6f405cd

[ "MIT" ]

1

2022-02-23T12:31:56.000Z

legacy/legacy_scripts/legacy/train_and_predict.py

tomkimpson/ML4L

ffa8360cb80df25bd6af4fa5cc39b42bd6f405cd

[ "MIT" ]

null

legacy/legacy_scripts/legacy/train_and_predict.py

tomkimpson/ML4L

ffa8360cb80df25bd6af4fa5cc39b42bd6f405cd

[ "MIT" ]

null

import tensorflow as tf import os import time import json import pandas as pd """ Script to train a sequential NN. Takes a df, filters based on `condition` (default None), and separates into test/train based on time NN trains on training data, all results output to disk """ def train_test_split(df,filter_condition,train_condition, test_condition,features,targets): """ Separate df into a train and test set. Returns training and testing dfs as well as split into inputs/outputs """ #Filter dataset if filter_condition is not None: df_filtered = df.query(filter_condition) else: df_filtered = df #Select train/test data training_data = df_filtered.query(train_condition) test_data = df_filtered.query(test_condition) #Separate into features/targets x_train = training_data[features] y_train = training_data[targets] x_test = test_data[features] y_test = test_data[targets] return x_train,y_train,x_test,y_test,training_data, test_data # def create_normalizer_layer(x_train): #Create a normaliser layer print ('Creating a normalization layer') normalizer = tf.keras.layers.Normalization(axis=-1) normalizer.adapt(x_train) return normalizer def train_NN(x_train,y_train,normalizer): #Check GPU available print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU'))) #Create a basic NN model model = tf.keras.Sequential([ normalizer, tf.keras.layers.Dense(int(len(features)/2), activation='relu',input_shape=(len(features),),name='layer1'), tf.keras.layers.Dense(1, name='output') ]) #Compile it print ('Compiling model') model.compile(optimizer='adam', loss='mse', metrics=['accuracy']) #Train it print('Training model') history = model.fit(x_train, y_train, epochs=100, batch_size=10000) return history, model def write_outputs(output_path,model,history,x_train,y_train,x_test,y_test,df_train,df_test): print ('Writing outputs to dir: ', fout) id = int(time.time()) fout = output_path+f'ML_{str(id)}/' os.makedirs(fout) print ('Writing outputs to dir: ', fout) #NN model.save(fout+'trained_model') history_dict = history.history json.dump(history_dict, open(fout+'history.json', 'w')) #Data #Probaby overkill saving all of these x_train.to_pickle(fout + "x_train.pkl") y_train.to_pickle(fout + "y_train.pkl") x_test.to_pickle(fout + "x_test.pkl") x_test.to_pickle(fout + "y_test.pkl") df_train.to_pickle(fout + "df_train.pkl") df_test.to_pickle(fout + "df_test.pkl") def pipeline(input_file,output_path,filter_condition,train_condition, test_condition,features): #Load the data print('Loading the data') df = pd.read_pickle(input_file) #Process into train/test targets = ['MODIS_LST'] x_train,y_train,x_test,y_test,df_train,df_test = train_test_split(df,filter_condition,train_condition, test_condition,features,targets) #Train NN normalizer = create_normalizer_layer(x_train) history,model = train_NN(x_train,y_train,normalizer) #Save trained NN in new dir, along with train/test sets write_outputs(output_path,model,history,x_train,y_train,x_test,y_test,df_train,df_test) #Parameters #IO input_file = '/network/group/aopp/predict/TIP016_PAXTON_RPSPEEDY/ML4L/ECMWF_files/raw/MODIS_ERA_joined_data_averaged.pkl' output_path = '/network/group/aopp/predict/TIP016_PAXTON_RPSPEEDY/ML4L/' #Pre Processing filter_condition = None train_condition = 'time < "2019-01-01 00:00:00"' test_condition = 'time >= "2020-01-01 00:00:00"' features = ['sp', 'msl', 'u10', 'v10','t2m', 'aluvp', 'aluvd', 'alnip', 'alnid', 'cl', 'cvl', 'cvh', 'slt', 'sdfor', 'z', 'sd', 'sdor', 'isor', 'anor', 'slor', 'd2m', 'lsm', 'fal'] #Go pipeline(input_file,output_path,filter_condition,train_condition, test_condition,features)

24.511765

139

0.673146

import tensorflow as tf import os import time import json import pandas as pd def train_test_split(df,filter_condition,train_condition, test_condition,features,targets): if filter_condition is not None: df_filtered = df.query(filter_condition) else: df_filtered = df training_data = df_filtered.query(train_condition) test_data = df_filtered.query(test_condition) x_train = training_data[features] y_train = training_data[targets] x_test = test_data[features] y_test = test_data[targets] return x_train,y_train,x_test,y_test,training_data, test_data def create_normalizer_layer(x_train): print ('Creating a normalization layer') normalizer = tf.keras.layers.Normalization(axis=-1) normalizer.adapt(x_train) return normalizer def train_NN(x_train,y_train,normalizer): print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU'))) model = tf.keras.Sequential([ normalizer, tf.keras.layers.Dense(int(len(features)/2), activation='relu',input_shape=(len(features),),name='layer1'), tf.keras.layers.Dense(1, name='output') ]) print ('Compiling model') model.compile(optimizer='adam', loss='mse', metrics=['accuracy']) print('Training model') history = model.fit(x_train, y_train, epochs=100, batch_size=10000) return history, model def write_outputs(output_path,model,history,x_train,y_train,x_test,y_test,df_train,df_test): print ('Writing outputs to dir: ', fout) id = int(time.time()) fout = output_path+f'ML_{str(id)}/' os.makedirs(fout) print ('Writing outputs to dir: ', fout) model.save(fout+'trained_model') history_dict = history.history json.dump(history_dict, open(fout+'history.json', 'w')) x_train.to_pickle(fout + "x_train.pkl") y_train.to_pickle(fout + "y_train.pkl") x_test.to_pickle(fout + "x_test.pkl") x_test.to_pickle(fout + "y_test.pkl") df_train.to_pickle(fout + "df_train.pkl") df_test.to_pickle(fout + "df_test.pkl") def pipeline(input_file,output_path,filter_condition,train_condition, test_condition,features): print('Loading the data') df = pd.read_pickle(input_file) targets = ['MODIS_LST'] x_train,y_train,x_test,y_test,df_train,df_test = train_test_split(df,filter_condition,train_condition, test_condition,features,targets) normalizer = create_normalizer_layer(x_train) history,model = train_NN(x_train,y_train,normalizer) write_outputs(output_path,model,history,x_train,y_train,x_test,y_test,df_train,df_test) input_file = '/network/group/aopp/predict/TIP016_PAXTON_RPSPEEDY/ML4L/ECMWF_files/raw/MODIS_ERA_joined_data_averaged.pkl' output_path = '/network/group/aopp/predict/TIP016_PAXTON_RPSPEEDY/ML4L/' filter_condition = None train_condition = 'time < "2019-01-01 00:00:00"' test_condition = 'time >= "2020-01-01 00:00:00"' features = ['sp', 'msl', 'u10', 'v10','t2m', 'aluvp', 'aluvd', 'alnip', 'alnid', 'cl', 'cvl', 'cvh', 'slt', 'sdfor', 'z', 'sd', 'sdor', 'isor', 'anor', 'slor', 'd2m', 'lsm', 'fal'] pipeline(input_file,output_path,filter_condition,train_condition, test_condition,features)

true

f713300b9992391c3e0a6ac558494cbba6e196e4

210

py

Python

vmraid/patches/v11_0/set_allow_self_approval_in_workflow.py

sowrisurya/vmraid

f833e00978019dad87af80b41279c0146c063ed5

[ "MIT" ]

null

vmraid/patches/v11_0/set_allow_self_approval_in_workflow.py

sowrisurya/vmraid

f833e00978019dad87af80b41279c0146c063ed5

[ "MIT" ]

null

vmraid/patches/v11_0/set_allow_self_approval_in_workflow.py

sowrisurya/vmraid

f833e00978019dad87af80b41279c0146c063ed5

[ "MIT" ]

null

from __future__ import unicode_literals import vmraid def execute(): vmraid.reload_doc("workflow", "doctype", "workflow_transition") vmraid.db.sql("update `tabWorkflow Transition` set allow_self_approval=1")

35

75

0.804762

from __future__ import unicode_literals import vmraid def execute(): vmraid.reload_doc("workflow", "doctype", "workflow_transition") vmraid.db.sql("update `tabWorkflow Transition` set allow_self_approval=1")

true

f713308df62e103bc3e47579221d1124cb26c36b

283

py

Python

changelogs/custom/pypi/synapse.py

chris48s/changelogs

0cdb929ac4546c766cd7eef9ae4eb4baaa08f452

[ "MIT" ]

null

changelogs/custom/pypi/synapse.py

chris48s/changelogs

0cdb929ac4546c766cd7eef9ae4eb4baaa08f452

[ "MIT" ]

null

changelogs/custom/pypi/synapse.py

chris48s/changelogs

0cdb929ac4546c766cd7eef9ae4eb4baaa08f452

[ "MIT" ]

null

def get_urls(releases, **kwargs): # Pypi has a old bugtracker_url which points to a separate repo which causes invalid # changelogs to be generated by this tool. ret = {'https://raw.githubusercontent.com/vertexproject/synapse/master/CHANGELOG.md'} return ret, set()

40.428571

89

0.731449

def get_urls(releases, **kwargs): ret = {'https://raw.githubusercontent.com/vertexproject/synapse/master/CHANGELOG.md'} return ret, set()

true

f7133143178ae049ac04338def1aceda35897e77

30,828

py

Python

tornado/test/simple_httpclient_test.py

dylanninin/tornado

d4094a0c2a7cddc654381c162ee7786d4bf8453b

[ "Apache-2.0" ]

null

tornado/test/simple_httpclient_test.py

dylanninin/tornado

d4094a0c2a7cddc654381c162ee7786d4bf8453b

[ "Apache-2.0" ]

null

tornado/test/simple_httpclient_test.py

dylanninin/tornado

d4094a0c2a7cddc654381c162ee7786d4bf8453b

[ "Apache-2.0" ]

1

2017-09-20T12:24:11.000Z

from __future__ import absolute_import, division, print_function import collections from contextlib import closing import errno import gzip import logging import os import re import socket import ssl import sys from tornado.escape import to_unicode from tornado import gen from tornado.httpclient import AsyncHTTPClient from tornado.httputil import HTTPHeaders, ResponseStartLine from tornado.ioloop import IOLoop from tornado.log import gen_log from tornado.concurrent import Future from tornado.netutil import Resolver, bind_sockets from tornado.simple_httpclient import SimpleAsyncHTTPClient from tornado.test.httpclient_test import ChunkHandler, CountdownHandler, HelloWorldHandler, RedirectHandler from tornado.test import httpclient_test from tornado.testing import AsyncHTTPTestCase, AsyncHTTPSTestCase, AsyncTestCase, ExpectLog from tornado.test.util import skipOnTravis, skipIfNoIPv6, refusing_port, unittest, skipBefore35, exec_test from tornado.web import RequestHandler, Application, asynchronous, url, stream_request_body class SimpleHTTPClientCommonTestCase(httpclient_test.HTTPClientCommonTestCase): def get_http_client(self): client = SimpleAsyncHTTPClient(force_instance=True) self.assertTrue(isinstance(client, SimpleAsyncHTTPClient)) return client class TriggerHandler(RequestHandler): def initialize(self, queue, wake_callback): self.queue = queue self.wake_callback = wake_callback @asynchronous def get(self): logging.debug("queuing trigger") self.queue.append(self.finish) if self.get_argument("wake", "true") == "true": self.wake_callback() class HangHandler(RequestHandler): @asynchronous def get(self): pass class ContentLengthHandler(RequestHandler): def get(self): self.set_header("Content-Length", self.get_argument("value")) self.write("ok") class HeadHandler(RequestHandler): def head(self): self.set_header("Content-Length", "7") class OptionsHandler(RequestHandler): def options(self): self.set_header("Access-Control-Allow-Origin", "*") self.write("ok") class NoContentHandler(RequestHandler): def get(self): self.set_status(204) self.finish() class SeeOtherPostHandler(RequestHandler): def post(self): redirect_code = int(self.request.body) assert redirect_code in (302, 303), "unexpected body %r" % self.request.body self.set_header("Location", "/see_other_get") self.set_status(redirect_code) class SeeOtherGetHandler(RequestHandler): def get(self): if self.request.body: raise Exception("unexpected body %r" % self.request.body) self.write("ok") class HostEchoHandler(RequestHandler): def get(self): self.write(self.request.headers["Host"]) class NoContentLengthHandler(RequestHandler): @asynchronous def get(self): if self.request.version.startswith('HTTP/1'): # Emulate the old HTTP/1.0 behavior of returning a body with no # content-length. Tornado handles content-length at the framework # level so we have to go around it. stream = self.request.connection.detach() stream.write(b"HTTP/1.0 200 OK\r\n\r\n" b"hello") stream.close() else: self.finish('HTTP/1 required') class EchoPostHandler(RequestHandler): def post(self): self.write(self.request.body) @stream_request_body class RespondInPrepareHandler(RequestHandler): def prepare(self): self.set_status(403) self.finish("forbidden") class SimpleHTTPClientTestMixin(object): def get_app(self): # callable objects to finish pending /trigger requests self.triggers = collections.deque() return Application([ url("/trigger", TriggerHandler, dict(queue=self.triggers, wake_callback=self.stop)), url("/chunk", ChunkHandler), url("/countdown/([0-9]+)", CountdownHandler, name="countdown"), url("/hang", HangHandler), url("/hello", HelloWorldHandler), url("/content_length", ContentLengthHandler), url("/head", HeadHandler), url("/options", OptionsHandler), url("/no_content", NoContentHandler), url("/see_other_post", SeeOtherPostHandler), url("/see_other_get", SeeOtherGetHandler), url("/host_echo", HostEchoHandler), url("/no_content_length", NoContentLengthHandler), url("/echo_post", EchoPostHandler), url("/respond_in_prepare", RespondInPrepareHandler), url("/redirect", RedirectHandler), ], gzip=True) def test_singleton(self): # Class "constructor" reuses objects on the same IOLoop self.assertTrue(SimpleAsyncHTTPClient() is SimpleAsyncHTTPClient()) # unless force_instance is used self.assertTrue(SimpleAsyncHTTPClient() is not SimpleAsyncHTTPClient(force_instance=True)) # different IOLoops use different objects with closing(IOLoop()) as io_loop2: client1 = self.io_loop.run_sync(gen.coroutine(SimpleAsyncHTTPClient)) client2 = io_loop2.run_sync(gen.coroutine(SimpleAsyncHTTPClient)) self.assertTrue(client1 is not client2) def test_connection_limit(self): with closing(self.create_client(max_clients=2)) as client: self.assertEqual(client.max_clients, 2) seen = [] # Send 4 requests. Two can be sent immediately, while the others # will be queued for i in range(4): client.fetch(self.get_url("/trigger"), lambda response, i=i: (seen.append(i), self.stop())) self.wait(condition=lambda: len(self.triggers) == 2) self.assertEqual(len(client.queue), 2) # Finish the first two requests and let the next two through self.triggers.popleft()() self.triggers.popleft()() self.wait(condition=lambda: (len(self.triggers) == 2 and len(seen) == 2)) self.assertEqual(set(seen), set([0, 1])) self.assertEqual(len(client.queue), 0) # Finish all the pending requests self.triggers.popleft()() self.triggers.popleft()() self.wait(condition=lambda: len(seen) == 4) self.assertEqual(set(seen), set([0, 1, 2, 3])) self.assertEqual(len(self.triggers), 0) def test_redirect_connection_limit(self): # following redirects should not consume additional connections with closing(self.create_client(max_clients=1)) as client: client.fetch(self.get_url('/countdown/3'), self.stop, max_redirects=3) response = self.wait() response.rethrow() def test_gzip(self): # All the tests in this file should be using gzip, but this test # ensures that it is in fact getting compressed. # Setting Accept-Encoding manually bypasses the client's # decompression so we can see the raw data. response = self.fetch("/chunk", use_gzip=False, headers={"Accept-Encoding": "gzip"}) self.assertEqual(response.headers["Content-Encoding"], "gzip") self.assertNotEqual(response.body, b"asdfqwer") # Our test data gets bigger when gzipped. Oops. :) # Chunked encoding bypasses the MIN_LENGTH check. self.assertEqual(len(response.body), 34) f = gzip.GzipFile(mode="r", fileobj=response.buffer) self.assertEqual(f.read(), b"asdfqwer") def test_max_redirects(self): response = self.fetch("/countdown/5", max_redirects=3) self.assertEqual(302, response.code) # We requested 5, followed three redirects for 4, 3, 2, then the last # unfollowed redirect is to 1. self.assertTrue(response.request.url.endswith("/countdown/5")) self.assertTrue(response.effective_url.endswith("/countdown/2")) self.assertTrue(response.headers["Location"].endswith("/countdown/1")) def test_header_reuse(self): # Apps may reuse a headers object if they are only passing in constant # headers like user-agent. The header object should not be modified. headers = HTTPHeaders({'User-Agent': 'Foo'}) self.fetch("/hello", headers=headers) self.assertEqual(list(headers.get_all()), [('User-Agent', 'Foo')]) def test_see_other_redirect(self): for code in (302, 303): response = self.fetch("/see_other_post", method="POST", body="%d" % code) self.assertEqual(200, response.code) self.assertTrue(response.request.url.endswith("/see_other_post")) self.assertTrue(response.effective_url.endswith("/see_other_get")) # request is the original request, is a POST still self.assertEqual("POST", response.request.method) @skipOnTravis def test_connect_timeout(self): timeout = 0.1 timeout_min, timeout_max = 0.099, 1.0 class TimeoutResolver(Resolver): def resolve(self, *args, **kwargs): return Future() # never completes with closing(self.create_client(resolver=TimeoutResolver())) as client: client.fetch(self.get_url('/hello'), self.stop, connect_timeout=timeout) response = self.wait() self.assertEqual(response.code, 599) self.assertTrue(timeout_min < response.request_time < timeout_max, response.request_time) self.assertEqual(str(response.error), "HTTP 599: Timeout while connecting") @skipOnTravis def test_request_timeout(self): timeout = 0.1 timeout_min, timeout_max = 0.099, 0.15 if os.name == 'nt': timeout = 0.5 timeout_min, timeout_max = 0.4, 0.6 response = self.fetch('/trigger?wake=false', request_timeout=timeout) self.assertEqual(response.code, 599) self.assertTrue(timeout_min < response.request_time < timeout_max, response.request_time) self.assertEqual(str(response.error), "HTTP 599: Timeout during request") # trigger the hanging request to let it clean up after itself self.triggers.popleft()() @skipIfNoIPv6 def test_ipv6(self): try: [sock] = bind_sockets(None, '::1', family=socket.AF_INET6) port = sock.getsockname()[1] self.http_server.add_socket(sock) except socket.gaierror as e: if e.args[0] == socket.EAI_ADDRFAMILY: # python supports ipv6, but it's not configured on the network # interface, so skip this test. return raise url = '%s://[::1]:%d/hello' % (self.get_protocol(), port) # ipv6 is currently enabled by default but can be disabled self.http_client.fetch(url, self.stop, allow_ipv6=False) response = self.wait() self.assertEqual(response.code, 599) self.http_client.fetch(url, self.stop) response = self.wait() self.assertEqual(response.body, b"Hello world!") def xtest_multiple_content_length_accepted(self): response = self.fetch("/content_length?value=2,2") self.assertEqual(response.body, b"ok") response = self.fetch("/content_length?value=2,%202,2") self.assertEqual(response.body, b"ok") response = self.fetch("/content_length?value=2,4") self.assertEqual(response.code, 599) response = self.fetch("/content_length?value=2,%202,3") self.assertEqual(response.code, 599) def test_head_request(self): response = self.fetch("/head", method="HEAD") self.assertEqual(response.code, 200) self.assertEqual(response.headers["content-length"], "7") self.assertFalse(response.body) def test_options_request(self): response = self.fetch("/options", method="OPTIONS") self.assertEqual(response.code, 200) self.assertEqual(response.headers["content-length"], "2") self.assertEqual(response.headers["access-control-allow-origin"], "*") self.assertEqual(response.body, b"ok") def test_no_content(self): response = self.fetch("/no_content") self.assertEqual(response.code, 204) # 204 status shouldn't have a content-length # # Tests with a content-length header are included below # in HTTP204NoContentTestCase. self.assertNotIn("Content-Length", response.headers) def test_host_header(self): host_re = re.compile(b"^localhost:[0-9]+$") response = self.fetch("/host_echo") self.assertTrue(host_re.match(response.body)) url = self.get_url("/host_echo").replace("http://", "http://me:secret@") self.http_client.fetch(url, self.stop) response = self.wait() self.assertTrue(host_re.match(response.body), response.body) def test_connection_refused(self): cleanup_func, port = refusing_port() self.addCleanup(cleanup_func) with ExpectLog(gen_log, ".*", required=False): self.http_client.fetch("http://127.0.0.1:%d/" % port, self.stop) response = self.wait() self.assertEqual(599, response.code) if sys.platform != 'cygwin': # cygwin returns EPERM instead of ECONNREFUSED here contains_errno = str(errno.ECONNREFUSED) in str(response.error) if not contains_errno and hasattr(errno, "WSAECONNREFUSED"): contains_errno = str(errno.WSAECONNREFUSED) in str(response.error) self.assertTrue(contains_errno, response.error) # This is usually "Connection refused". # On windows, strerror is broken and returns "Unknown error". expected_message = os.strerror(errno.ECONNREFUSED) self.assertTrue(expected_message in str(response.error), response.error) def test_queue_timeout(self): with closing(self.create_client(max_clients=1)) as client: client.fetch(self.get_url('/trigger'), self.stop, request_timeout=10) # Wait for the trigger request to block, not complete. self.wait() client.fetch(self.get_url('/hello'), self.stop, connect_timeout=0.1) response = self.wait() self.assertEqual(response.code, 599) self.assertTrue(response.request_time < 1, response.request_time) self.assertEqual(str(response.error), "HTTP 599: Timeout in request queue") self.triggers.popleft()() self.wait() def test_no_content_length(self): response = self.fetch("/no_content_length") if response.body == b"HTTP/1 required": self.skipTest("requires HTTP/1.x") else: self.assertEquals(b"hello", response.body) def sync_body_producer(self, write): write(b'1234') write(b'5678') @gen.coroutine def async_body_producer(self, write): yield write(b'1234') yield gen.Task(IOLoop.current().add_callback) yield write(b'5678') def test_sync_body_producer_chunked(self): response = self.fetch("/echo_post", method="POST", body_producer=self.sync_body_producer) response.rethrow() self.assertEqual(response.body, b"12345678") def test_sync_body_producer_content_length(self): response = self.fetch("/echo_post", method="POST", body_producer=self.sync_body_producer, headers={'Content-Length': '8'}) response.rethrow() self.assertEqual(response.body, b"12345678") def test_async_body_producer_chunked(self): response = self.fetch("/echo_post", method="POST", body_producer=self.async_body_producer) response.rethrow() self.assertEqual(response.body, b"12345678") def test_async_body_producer_content_length(self): response = self.fetch("/echo_post", method="POST", body_producer=self.async_body_producer, headers={'Content-Length': '8'}) response.rethrow() self.assertEqual(response.body, b"12345678") @skipBefore35 def test_native_body_producer_chunked(self): namespace = exec_test(globals(), locals(), """ async def body_producer(write): await write(b'1234') await gen.Task(IOLoop.current().add_callback) await write(b'5678') """) response = self.fetch("/echo_post", method="POST", body_producer=namespace["body_producer"]) response.rethrow() self.assertEqual(response.body, b"12345678") @skipBefore35 def test_native_body_producer_content_length(self): namespace = exec_test(globals(), locals(), """ async def body_producer(write): await write(b'1234') await gen.Task(IOLoop.current().add_callback) await write(b'5678') """) response = self.fetch("/echo_post", method="POST", body_producer=namespace["body_producer"], headers={'Content-Length': '8'}) response.rethrow() self.assertEqual(response.body, b"12345678") def test_100_continue(self): response = self.fetch("/echo_post", method="POST", body=b"1234", expect_100_continue=True) self.assertEqual(response.body, b"1234") def test_100_continue_early_response(self): def body_producer(write): raise Exception("should not be called") response = self.fetch("/respond_in_prepare", method="POST", body_producer=body_producer, expect_100_continue=True) self.assertEqual(response.code, 403) def test_streaming_follow_redirects(self): # When following redirects, header and streaming callbacks # should only be called for the final result. # TODO(bdarnell): this test belongs in httpclient_test instead of # simple_httpclient_test, but it fails with the version of libcurl # available on travis-ci. Move it when that has been upgraded # or we have a better framework to skip tests based on curl version. headers = [] chunks = [] self.fetch("/redirect?url=/hello", header_callback=headers.append, streaming_callback=chunks.append) chunks = list(map(to_unicode, chunks)) self.assertEqual(chunks, ['Hello world!']) # Make sure we only got one set of headers. num_start_lines = len([h for h in headers if h.startswith("HTTP/")]) self.assertEqual(num_start_lines, 1) class SimpleHTTPClientTestCase(SimpleHTTPClientTestMixin, AsyncHTTPTestCase): def setUp(self): super(SimpleHTTPClientTestCase, self).setUp() self.http_client = self.create_client() def create_client(self, **kwargs): return SimpleAsyncHTTPClient(force_instance=True, **kwargs) class SimpleHTTPSClientTestCase(SimpleHTTPClientTestMixin, AsyncHTTPSTestCase): def setUp(self): super(SimpleHTTPSClientTestCase, self).setUp() self.http_client = self.create_client() def create_client(self, **kwargs): return SimpleAsyncHTTPClient(force_instance=True, defaults=dict(validate_cert=False), **kwargs) def test_ssl_options(self): resp = self.fetch("/hello", ssl_options={}) self.assertEqual(resp.body, b"Hello world!") @unittest.skipIf(not hasattr(ssl, 'SSLContext'), 'ssl.SSLContext not present') def test_ssl_context(self): resp = self.fetch("/hello", ssl_options=ssl.SSLContext(ssl.PROTOCOL_SSLv23)) self.assertEqual(resp.body, b"Hello world!") def test_ssl_options_handshake_fail(self): with ExpectLog(gen_log, "SSL Error|Uncaught exception", required=False): resp = self.fetch( "/hello", ssl_options=dict(cert_reqs=ssl.CERT_REQUIRED)) self.assertRaises(ssl.SSLError, resp.rethrow) @unittest.skipIf(not hasattr(ssl, 'SSLContext'), 'ssl.SSLContext not present') def test_ssl_context_handshake_fail(self): with ExpectLog(gen_log, "SSL Error|Uncaught exception"): ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.verify_mode = ssl.CERT_REQUIRED resp = self.fetch("/hello", ssl_options=ctx) self.assertRaises(ssl.SSLError, resp.rethrow) def test_error_logging(self): # No stack traces are logged for SSL errors (in this case, # failure to validate the testing self-signed cert). # The SSLError is exposed through ssl.SSLError. with ExpectLog(gen_log, '.*') as expect_log: response = self.fetch("/", validate_cert=True) self.assertEqual(response.code, 599) self.assertIsInstance(response.error, ssl.SSLError) self.assertFalse(expect_log.logged_stack) class CreateAsyncHTTPClientTestCase(AsyncTestCase): def setUp(self): super(CreateAsyncHTTPClientTestCase, self).setUp() self.saved = AsyncHTTPClient._save_configuration() def tearDown(self): AsyncHTTPClient._restore_configuration(self.saved) super(CreateAsyncHTTPClientTestCase, self).tearDown() def test_max_clients(self): AsyncHTTPClient.configure(SimpleAsyncHTTPClient) with closing(AsyncHTTPClient(force_instance=True)) as client: self.assertEqual(client.max_clients, 10) with closing(AsyncHTTPClient( max_clients=11, force_instance=True)) as client: self.assertEqual(client.max_clients, 11) # Now configure max_clients statically and try overriding it # with each way max_clients can be passed AsyncHTTPClient.configure(SimpleAsyncHTTPClient, max_clients=12) with closing(AsyncHTTPClient(force_instance=True)) as client: self.assertEqual(client.max_clients, 12) with closing(AsyncHTTPClient( max_clients=13, force_instance=True)) as client: self.assertEqual(client.max_clients, 13) with closing(AsyncHTTPClient( max_clients=14, force_instance=True)) as client: self.assertEqual(client.max_clients, 14) class HTTP100ContinueTestCase(AsyncHTTPTestCase): def respond_100(self, request): self.http1 = request.version.startswith('HTTP/1.') if not self.http1: request.connection.write_headers(ResponseStartLine('', 200, 'OK'), HTTPHeaders()) request.connection.finish() return self.request = request self.request.connection.stream.write( b"HTTP/1.1 100 CONTINUE\r\n\r\n", self.respond_200) def respond_200(self): self.request.connection.stream.write( b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\n\r\nA", self.request.connection.stream.close) def get_app(self): # Not a full Application, but works as an HTTPServer callback return self.respond_100 def test_100_continue(self): res = self.fetch('/') if not self.http1: self.skipTest("requires HTTP/1.x") self.assertEqual(res.body, b'A') class HTTP204NoContentTestCase(AsyncHTTPTestCase): def respond_204(self, request): self.http1 = request.version.startswith('HTTP/1.') if not self.http1: # Close the request cleanly in HTTP/2; it will be skipped anyway. request.connection.write_headers(ResponseStartLine('', 200, 'OK'), HTTPHeaders()) request.connection.finish() return # A 204 response never has a body, even if doesn't have a content-length # (which would otherwise mean read-until-close). We simulate here a # server that sends no content length and does not close the connection. # # Tests of a 204 response with no Content-Length header are included # in SimpleHTTPClientTestMixin. stream = request.connection.detach() stream.write(b"HTTP/1.1 204 No content\r\n") if request.arguments.get("error", [False])[-1]: stream.write(b"Content-Length: 5\r\n") else: stream.write(b"Content-Length: 0\r\n") stream.write(b"\r\n") stream.close() def get_app(self): return self.respond_204 def test_204_no_content(self): resp = self.fetch('/') if not self.http1: self.skipTest("requires HTTP/1.x") self.assertEqual(resp.code, 204) self.assertEqual(resp.body, b'') def test_204_invalid_content_length(self): # 204 status with non-zero content length is malformed with ExpectLog(gen_log, ".*Response with code 204 should not have body"): response = self.fetch("/?error=1") if not self.http1: self.skipTest("requires HTTP/1.x") if self.http_client.configured_class != SimpleAsyncHTTPClient: self.skipTest("curl client accepts invalid headers") self.assertEqual(response.code, 599) class HostnameMappingTestCase(AsyncHTTPTestCase): def setUp(self): super(HostnameMappingTestCase, self).setUp() self.http_client = SimpleAsyncHTTPClient( hostname_mapping={ 'www.example.com': '127.0.0.1', ('foo.example.com', 8000): ('127.0.0.1', self.get_http_port()), }) def get_app(self): return Application([url("/hello", HelloWorldHandler), ]) def test_hostname_mapping(self): self.http_client.fetch( 'http://www.example.com:%d/hello' % self.get_http_port(), self.stop) response = self.wait() response.rethrow() self.assertEqual(response.body, b'Hello world!') def test_port_mapping(self): self.http_client.fetch('http://foo.example.com:8000/hello', self.stop) response = self.wait() response.rethrow() self.assertEqual(response.body, b'Hello world!') class ResolveTimeoutTestCase(AsyncHTTPTestCase): def setUp(self): # Dummy Resolver subclass that never invokes its callback. class BadResolver(Resolver): def resolve(self, *args, **kwargs): pass super(ResolveTimeoutTestCase, self).setUp() self.http_client = SimpleAsyncHTTPClient( resolver=BadResolver()) def get_app(self): return Application([url("/hello", HelloWorldHandler), ]) def test_resolve_timeout(self): response = self.fetch('/hello', connect_timeout=0.1) self.assertEqual(response.code, 599) class MaxHeaderSizeTest(AsyncHTTPTestCase): def get_app(self): class SmallHeaders(RequestHandler): def get(self): self.set_header("X-Filler", "a" * 100) self.write("ok") class LargeHeaders(RequestHandler): def get(self): self.set_header("X-Filler", "a" * 1000) self.write("ok") return Application([('/small', SmallHeaders), ('/large', LargeHeaders)]) def get_http_client(self): return SimpleAsyncHTTPClient(max_header_size=1024) def test_small_headers(self): response = self.fetch('/small') response.rethrow() self.assertEqual(response.body, b'ok') def test_large_headers(self): with ExpectLog(gen_log, "Unsatisfiable read"): response = self.fetch('/large') self.assertEqual(response.code, 599) class MaxBodySizeTest(AsyncHTTPTestCase): def get_app(self): class SmallBody(RequestHandler): def get(self): self.write("a" * 1024 * 64) class LargeBody(RequestHandler): def get(self): self.write("a" * 1024 * 100) return Application([('/small', SmallBody), ('/large', LargeBody)]) def get_http_client(self): return SimpleAsyncHTTPClient(max_body_size=1024 * 64) def test_small_body(self): response = self.fetch('/small') response.rethrow() self.assertEqual(response.body, b'a' * 1024 * 64) def test_large_body(self): with ExpectLog(gen_log, "Malformed HTTP message from None: Content-Length too long"): response = self.fetch('/large') self.assertEqual(response.code, 599) class MaxBufferSizeTest(AsyncHTTPTestCase): def get_app(self): class LargeBody(RequestHandler): def get(self): self.write("a" * 1024 * 100) return Application([('/large', LargeBody)]) def get_http_client(self): # 100KB body with 64KB buffer return SimpleAsyncHTTPClient(max_body_size=1024 * 100, max_buffer_size=1024 * 64) def test_large_body(self): response = self.fetch('/large') response.rethrow() self.assertEqual(response.body, b'a' * 1024 * 100) class ChunkedWithContentLengthTest(AsyncHTTPTestCase): def get_app(self): class ChunkedWithContentLength(RequestHandler): def get(self): # Add an invalid Transfer-Encoding to the response self.set_header('Transfer-Encoding', 'chunked') self.write("Hello world") return Application([('/chunkwithcl', ChunkedWithContentLength)]) def get_http_client(self): return SimpleAsyncHTTPClient() def test_chunked_with_content_length(self): # Make sure the invalid headers are detected with ExpectLog(gen_log, ("Malformed HTTP message from None: Response " "with both Transfer-Encoding and Content-Length")): response = self.fetch('/chunkwithcl') self.assertEqual(response.code, 599)

39.573813

107

0.628941

from __future__ import absolute_import, division, print_function import collections from contextlib import closing import errno import gzip import logging import os import re import socket import ssl import sys from tornado.escape import to_unicode from tornado import gen from tornado.httpclient import AsyncHTTPClient from tornado.httputil import HTTPHeaders, ResponseStartLine from tornado.ioloop import IOLoop from tornado.log import gen_log from tornado.concurrent import Future from tornado.netutil import Resolver, bind_sockets from tornado.simple_httpclient import SimpleAsyncHTTPClient from tornado.test.httpclient_test import ChunkHandler, CountdownHandler, HelloWorldHandler, RedirectHandler from tornado.test import httpclient_test from tornado.testing import AsyncHTTPTestCase, AsyncHTTPSTestCase, AsyncTestCase, ExpectLog from tornado.test.util import skipOnTravis, skipIfNoIPv6, refusing_port, unittest, skipBefore35, exec_test from tornado.web import RequestHandler, Application, asynchronous, url, stream_request_body class SimpleHTTPClientCommonTestCase(httpclient_test.HTTPClientCommonTestCase): def get_http_client(self): client = SimpleAsyncHTTPClient(force_instance=True) self.assertTrue(isinstance(client, SimpleAsyncHTTPClient)) return client class TriggerHandler(RequestHandler): def initialize(self, queue, wake_callback): self.queue = queue self.wake_callback = wake_callback @asynchronous def get(self): logging.debug("queuing trigger") self.queue.append(self.finish) if self.get_argument("wake", "true") == "true": self.wake_callback() class HangHandler(RequestHandler): @asynchronous def get(self): pass class ContentLengthHandler(RequestHandler): def get(self): self.set_header("Content-Length", self.get_argument("value")) self.write("ok") class HeadHandler(RequestHandler): def head(self): self.set_header("Content-Length", "7") class OptionsHandler(RequestHandler): def options(self): self.set_header("Access-Control-Allow-Origin", "*") self.write("ok") class NoContentHandler(RequestHandler): def get(self): self.set_status(204) self.finish() class SeeOtherPostHandler(RequestHandler): def post(self): redirect_code = int(self.request.body) assert redirect_code in (302, 303), "unexpected body %r" % self.request.body self.set_header("Location", "/see_other_get") self.set_status(redirect_code) class SeeOtherGetHandler(RequestHandler): def get(self): if self.request.body: raise Exception("unexpected body %r" % self.request.body) self.write("ok") class HostEchoHandler(RequestHandler): def get(self): self.write(self.request.headers["Host"]) class NoContentLengthHandler(RequestHandler): @asynchronous def get(self): if self.request.version.startswith('HTTP/1'): stream = self.request.connection.detach() stream.write(b"HTTP/1.0 200 OK\r\n\r\n" b"hello") stream.close() else: self.finish('HTTP/1 required') class EchoPostHandler(RequestHandler): def post(self): self.write(self.request.body) @stream_request_body class RespondInPrepareHandler(RequestHandler): def prepare(self): self.set_status(403) self.finish("forbidden") class SimpleHTTPClientTestMixin(object): def get_app(self): self.triggers = collections.deque() return Application([ url("/trigger", TriggerHandler, dict(queue=self.triggers, wake_callback=self.stop)), url("/chunk", ChunkHandler), url("/countdown/([0-9]+)", CountdownHandler, name="countdown"), url("/hang", HangHandler), url("/hello", HelloWorldHandler), url("/content_length", ContentLengthHandler), url("/head", HeadHandler), url("/options", OptionsHandler), url("/no_content", NoContentHandler), url("/see_other_post", SeeOtherPostHandler), url("/see_other_get", SeeOtherGetHandler), url("/host_echo", HostEchoHandler), url("/no_content_length", NoContentLengthHandler), url("/echo_post", EchoPostHandler), url("/respond_in_prepare", RespondInPrepareHandler), url("/redirect", RedirectHandler), ], gzip=True) def test_singleton(self): self.assertTrue(SimpleAsyncHTTPClient() is SimpleAsyncHTTPClient()) self.assertTrue(SimpleAsyncHTTPClient() is not SimpleAsyncHTTPClient(force_instance=True)) with closing(IOLoop()) as io_loop2: client1 = self.io_loop.run_sync(gen.coroutine(SimpleAsyncHTTPClient)) client2 = io_loop2.run_sync(gen.coroutine(SimpleAsyncHTTPClient)) self.assertTrue(client1 is not client2) def test_connection_limit(self): with closing(self.create_client(max_clients=2)) as client: self.assertEqual(client.max_clients, 2) seen = [] for i in range(4): client.fetch(self.get_url("/trigger"), lambda response, i=i: (seen.append(i), self.stop())) self.wait(condition=lambda: len(self.triggers) == 2) self.assertEqual(len(client.queue), 2) self.triggers.popleft()() self.triggers.popleft()() self.wait(condition=lambda: (len(self.triggers) == 2 and len(seen) == 2)) self.assertEqual(set(seen), set([0, 1])) self.assertEqual(len(client.queue), 0) self.triggers.popleft()() self.triggers.popleft()() self.wait(condition=lambda: len(seen) == 4) self.assertEqual(set(seen), set([0, 1, 2, 3])) self.assertEqual(len(self.triggers), 0) def test_redirect_connection_limit(self): with closing(self.create_client(max_clients=1)) as client: client.fetch(self.get_url('/countdown/3'), self.stop, max_redirects=3) response = self.wait() response.rethrow() def test_gzip(self): # decompression so we can see the raw data. response = self.fetch("/chunk", use_gzip=False, headers={"Accept-Encoding": "gzip"}) self.assertEqual(response.headers["Content-Encoding"], "gzip") self.assertNotEqual(response.body, b"asdfqwer") # Our test data gets bigger when gzipped. Oops. :) # Chunked encoding bypasses the MIN_LENGTH check. self.assertEqual(len(response.body), 34) f = gzip.GzipFile(mode="r", fileobj=response.buffer) self.assertEqual(f.read(), b"asdfqwer") def test_max_redirects(self): response = self.fetch("/countdown/5", max_redirects=3) self.assertEqual(302, response.code) # We requested 5, followed three redirects for 4, 3, 2, then the last # unfollowed redirect is to 1. self.assertTrue(response.request.url.endswith("/countdown/5")) self.assertTrue(response.effective_url.endswith("/countdown/2")) self.assertTrue(response.headers["Location"].endswith("/countdown/1")) def test_header_reuse(self): # Apps may reuse a headers object if they are only passing in constant # headers like user-agent. The header object should not be modified. headers = HTTPHeaders({'User-Agent': 'Foo'}) self.fetch("/hello", headers=headers) self.assertEqual(list(headers.get_all()), [('User-Agent', 'Foo')]) def test_see_other_redirect(self): for code in (302, 303): response = self.fetch("/see_other_post", method="POST", body="%d" % code) self.assertEqual(200, response.code) self.assertTrue(response.request.url.endswith("/see_other_post")) self.assertTrue(response.effective_url.endswith("/see_other_get")) # request is the original request, is a POST still self.assertEqual("POST", response.request.method) @skipOnTravis def test_connect_timeout(self): timeout = 0.1 timeout_min, timeout_max = 0.099, 1.0 class TimeoutResolver(Resolver): def resolve(self, *args, **kwargs): return Future() # never completes with closing(self.create_client(resolver=TimeoutResolver())) as client: client.fetch(self.get_url('/hello'), self.stop, connect_timeout=timeout) response = self.wait() self.assertEqual(response.code, 599) self.assertTrue(timeout_min < response.request_time < timeout_max, response.request_time) self.assertEqual(str(response.error), "HTTP 599: Timeout while connecting") @skipOnTravis def test_request_timeout(self): timeout = 0.1 timeout_min, timeout_max = 0.099, 0.15 if os.name == 'nt': timeout = 0.5 timeout_min, timeout_max = 0.4, 0.6 response = self.fetch('/trigger?wake=false', request_timeout=timeout) self.assertEqual(response.code, 599) self.assertTrue(timeout_min < response.request_time < timeout_max, response.request_time) self.assertEqual(str(response.error), "HTTP 599: Timeout during request") # trigger the hanging request to let it clean up after itself self.triggers.popleft()() @skipIfNoIPv6 def test_ipv6(self): try: [sock] = bind_sockets(None, '::1', family=socket.AF_INET6) port = sock.getsockname()[1] self.http_server.add_socket(sock) except socket.gaierror as e: if e.args[0] == socket.EAI_ADDRFAMILY: # python supports ipv6, but it's not configured on the network return raise url = '%s://[::1]:%d/hello' % (self.get_protocol(), port) self.http_client.fetch(url, self.stop, allow_ipv6=False) response = self.wait() self.assertEqual(response.code, 599) self.http_client.fetch(url, self.stop) response = self.wait() self.assertEqual(response.body, b"Hello world!") def xtest_multiple_content_length_accepted(self): response = self.fetch("/content_length?value=2,2") self.assertEqual(response.body, b"ok") response = self.fetch("/content_length?value=2,%202,2") self.assertEqual(response.body, b"ok") response = self.fetch("/content_length?value=2,4") self.assertEqual(response.code, 599) response = self.fetch("/content_length?value=2,%202,3") self.assertEqual(response.code, 599) def test_head_request(self): response = self.fetch("/head", method="HEAD") self.assertEqual(response.code, 200) self.assertEqual(response.headers["content-length"], "7") self.assertFalse(response.body) def test_options_request(self): response = self.fetch("/options", method="OPTIONS") self.assertEqual(response.code, 200) self.assertEqual(response.headers["content-length"], "2") self.assertEqual(response.headers["access-control-allow-origin"], "*") self.assertEqual(response.body, b"ok") def test_no_content(self): response = self.fetch("/no_content") self.assertEqual(response.code, 204) # # Tests with a content-length header are included below # in HTTP204NoContentTestCase. self.assertNotIn("Content-Length", response.headers) def test_host_header(self): host_re = re.compile(b"^localhost:[0-9]+$") response = self.fetch("/host_echo") self.assertTrue(host_re.match(response.body)) url = self.get_url("/host_echo").replace("http://", "http://me:secret@") self.http_client.fetch(url, self.stop) response = self.wait() self.assertTrue(host_re.match(response.body), response.body) def test_connection_refused(self): cleanup_func, port = refusing_port() self.addCleanup(cleanup_func) with ExpectLog(gen_log, ".*", required=False): self.http_client.fetch("http://127.0.0.1:%d/" % port, self.stop) response = self.wait() self.assertEqual(599, response.code) if sys.platform != 'cygwin': # cygwin returns EPERM instead of ECONNREFUSED here contains_errno = str(errno.ECONNREFUSED) in str(response.error) if not contains_errno and hasattr(errno, "WSAECONNREFUSED"): contains_errno = str(errno.WSAECONNREFUSED) in str(response.error) self.assertTrue(contains_errno, response.error) # This is usually "Connection refused". # On windows, strerror is broken and returns "Unknown error". expected_message = os.strerror(errno.ECONNREFUSED) self.assertTrue(expected_message in str(response.error), response.error) def test_queue_timeout(self): with closing(self.create_client(max_clients=1)) as client: client.fetch(self.get_url('/trigger'), self.stop, request_timeout=10) # Wait for the trigger request to block, not complete. self.wait() client.fetch(self.get_url('/hello'), self.stop, connect_timeout=0.1) response = self.wait() self.assertEqual(response.code, 599) self.assertTrue(response.request_time < 1, response.request_time) self.assertEqual(str(response.error), "HTTP 599: Timeout in request queue") self.triggers.popleft()() self.wait() def test_no_content_length(self): response = self.fetch("/no_content_length") if response.body == b"HTTP/1 required": self.skipTest("requires HTTP/1.x") else: self.assertEquals(b"hello", response.body) def sync_body_producer(self, write): write(b'1234') write(b'5678') @gen.coroutine def async_body_producer(self, write): yield write(b'1234') yield gen.Task(IOLoop.current().add_callback) yield write(b'5678') def test_sync_body_producer_chunked(self): response = self.fetch("/echo_post", method="POST", body_producer=self.sync_body_producer) response.rethrow() self.assertEqual(response.body, b"12345678") def test_sync_body_producer_content_length(self): response = self.fetch("/echo_post", method="POST", body_producer=self.sync_body_producer, headers={'Content-Length': '8'}) response.rethrow() self.assertEqual(response.body, b"12345678") def test_async_body_producer_chunked(self): response = self.fetch("/echo_post", method="POST", body_producer=self.async_body_producer) response.rethrow() self.assertEqual(response.body, b"12345678") def test_async_body_producer_content_length(self): response = self.fetch("/echo_post", method="POST", body_producer=self.async_body_producer, headers={'Content-Length': '8'}) response.rethrow() self.assertEqual(response.body, b"12345678") @skipBefore35 def test_native_body_producer_chunked(self): namespace = exec_test(globals(), locals(), """ async def body_producer(write): await write(b'1234') await gen.Task(IOLoop.current().add_callback) await write(b'5678') """) response = self.fetch("/echo_post", method="POST", body_producer=namespace["body_producer"]) response.rethrow() self.assertEqual(response.body, b"12345678") @skipBefore35 def test_native_body_producer_content_length(self): namespace = exec_test(globals(), locals(), """ async def body_producer(write): await write(b'1234') await gen.Task(IOLoop.current().add_callback) await write(b'5678') """) response = self.fetch("/echo_post", method="POST", body_producer=namespace["body_producer"], headers={'Content-Length': '8'}) response.rethrow() self.assertEqual(response.body, b"12345678") def test_100_continue(self): response = self.fetch("/echo_post", method="POST", body=b"1234", expect_100_continue=True) self.assertEqual(response.body, b"1234") def test_100_continue_early_response(self): def body_producer(write): raise Exception("should not be called") response = self.fetch("/respond_in_prepare", method="POST", body_producer=body_producer, expect_100_continue=True) self.assertEqual(response.code, 403) def test_streaming_follow_redirects(self): # When following redirects, header and streaming callbacks # should only be called for the final result. # TODO(bdarnell): this test belongs in httpclient_test instead of # simple_httpclient_test, but it fails with the version of libcurl # available on travis-ci. Move it when that has been upgraded # or we have a better framework to skip tests based on curl version. headers = [] chunks = [] self.fetch("/redirect?url=/hello", header_callback=headers.append, streaming_callback=chunks.append) chunks = list(map(to_unicode, chunks)) self.assertEqual(chunks, ['Hello world!']) # Make sure we only got one set of headers. num_start_lines = len([h for h in headers if h.startswith("HTTP/")]) self.assertEqual(num_start_lines, 1) class SimpleHTTPClientTestCase(SimpleHTTPClientTestMixin, AsyncHTTPTestCase): def setUp(self): super(SimpleHTTPClientTestCase, self).setUp() self.http_client = self.create_client() def create_client(self, **kwargs): return SimpleAsyncHTTPClient(force_instance=True, **kwargs) class SimpleHTTPSClientTestCase(SimpleHTTPClientTestMixin, AsyncHTTPSTestCase): def setUp(self): super(SimpleHTTPSClientTestCase, self).setUp() self.http_client = self.create_client() def create_client(self, **kwargs): return SimpleAsyncHTTPClient(force_instance=True, defaults=dict(validate_cert=False), **kwargs) def test_ssl_options(self): resp = self.fetch("/hello", ssl_options={}) self.assertEqual(resp.body, b"Hello world!") @unittest.skipIf(not hasattr(ssl, 'SSLContext'), 'ssl.SSLContext not present') def test_ssl_context(self): resp = self.fetch("/hello", ssl_options=ssl.SSLContext(ssl.PROTOCOL_SSLv23)) self.assertEqual(resp.body, b"Hello world!") def test_ssl_options_handshake_fail(self): with ExpectLog(gen_log, "SSL Error|Uncaught exception", required=False): resp = self.fetch( "/hello", ssl_options=dict(cert_reqs=ssl.CERT_REQUIRED)) self.assertRaises(ssl.SSLError, resp.rethrow) @unittest.skipIf(not hasattr(ssl, 'SSLContext'), 'ssl.SSLContext not present') def test_ssl_context_handshake_fail(self): with ExpectLog(gen_log, "SSL Error|Uncaught exception"): ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.verify_mode = ssl.CERT_REQUIRED resp = self.fetch("/hello", ssl_options=ctx) self.assertRaises(ssl.SSLError, resp.rethrow) def test_error_logging(self): # No stack traces are logged for SSL errors (in this case, # failure to validate the testing self-signed cert). # The SSLError is exposed through ssl.SSLError. with ExpectLog(gen_log, '.*') as expect_log: response = self.fetch("/", validate_cert=True) self.assertEqual(response.code, 599) self.assertIsInstance(response.error, ssl.SSLError) self.assertFalse(expect_log.logged_stack) class CreateAsyncHTTPClientTestCase(AsyncTestCase): def setUp(self): super(CreateAsyncHTTPClientTestCase, self).setUp() self.saved = AsyncHTTPClient._save_configuration() def tearDown(self): AsyncHTTPClient._restore_configuration(self.saved) super(CreateAsyncHTTPClientTestCase, self).tearDown() def test_max_clients(self): AsyncHTTPClient.configure(SimpleAsyncHTTPClient) with closing(AsyncHTTPClient(force_instance=True)) as client: self.assertEqual(client.max_clients, 10) with closing(AsyncHTTPClient( max_clients=11, force_instance=True)) as client: self.assertEqual(client.max_clients, 11) # Now configure max_clients statically and try overriding it # with each way max_clients can be passed AsyncHTTPClient.configure(SimpleAsyncHTTPClient, max_clients=12) with closing(AsyncHTTPClient(force_instance=True)) as client: self.assertEqual(client.max_clients, 12) with closing(AsyncHTTPClient( max_clients=13, force_instance=True)) as client: self.assertEqual(client.max_clients, 13) with closing(AsyncHTTPClient( max_clients=14, force_instance=True)) as client: self.assertEqual(client.max_clients, 14) class HTTP100ContinueTestCase(AsyncHTTPTestCase): def respond_100(self, request): self.http1 = request.version.startswith('HTTP/1.') if not self.http1: request.connection.write_headers(ResponseStartLine('', 200, 'OK'), HTTPHeaders()) request.connection.finish() return self.request = request self.request.connection.stream.write( b"HTTP/1.1 100 CONTINUE\r\n\r\n", self.respond_200) def respond_200(self): self.request.connection.stream.write( b"HTTP/1.1 200 OK\r\nContent-Length: 1\r\n\r\nA", self.request.connection.stream.close) def get_app(self): # Not a full Application, but works as an HTTPServer callback return self.respond_100 def test_100_continue(self): res = self.fetch('/') if not self.http1: self.skipTest("requires HTTP/1.x") self.assertEqual(res.body, b'A') class HTTP204NoContentTestCase(AsyncHTTPTestCase): def respond_204(self, request): self.http1 = request.version.startswith('HTTP/1.') if not self.http1: # Close the request cleanly in HTTP/2; it will be skipped anyway. request.connection.write_headers(ResponseStartLine('', 200, 'OK'), HTTPHeaders()) request.connection.finish() return # A 204 response never has a body, even if doesn't have a content-length stream = request.connection.detach() stream.write(b"HTTP/1.1 204 No content\r\n") if request.arguments.get("error", [False])[-1]: stream.write(b"Content-Length: 5\r\n") else: stream.write(b"Content-Length: 0\r\n") stream.write(b"\r\n") stream.close() def get_app(self): return self.respond_204 def test_204_no_content(self): resp = self.fetch('/') if not self.http1: self.skipTest("requires HTTP/1.x") self.assertEqual(resp.code, 204) self.assertEqual(resp.body, b'') def test_204_invalid_content_length(self): with ExpectLog(gen_log, ".*Response with code 204 should not have body"): response = self.fetch("/?error=1") if not self.http1: self.skipTest("requires HTTP/1.x") if self.http_client.configured_class != SimpleAsyncHTTPClient: self.skipTest("curl client accepts invalid headers") self.assertEqual(response.code, 599) class HostnameMappingTestCase(AsyncHTTPTestCase): def setUp(self): super(HostnameMappingTestCase, self).setUp() self.http_client = SimpleAsyncHTTPClient( hostname_mapping={ 'www.example.com': '127.0.0.1', ('foo.example.com', 8000): ('127.0.0.1', self.get_http_port()), }) def get_app(self): return Application([url("/hello", HelloWorldHandler), ]) def test_hostname_mapping(self): self.http_client.fetch( 'http://www.example.com:%d/hello' % self.get_http_port(), self.stop) response = self.wait() response.rethrow() self.assertEqual(response.body, b'Hello world!') def test_port_mapping(self): self.http_client.fetch('http://foo.example.com:8000/hello', self.stop) response = self.wait() response.rethrow() self.assertEqual(response.body, b'Hello world!') class ResolveTimeoutTestCase(AsyncHTTPTestCase): def setUp(self): class BadResolver(Resolver): def resolve(self, *args, **kwargs): pass super(ResolveTimeoutTestCase, self).setUp() self.http_client = SimpleAsyncHTTPClient( resolver=BadResolver()) def get_app(self): return Application([url("/hello", HelloWorldHandler), ]) def test_resolve_timeout(self): response = self.fetch('/hello', connect_timeout=0.1) self.assertEqual(response.code, 599) class MaxHeaderSizeTest(AsyncHTTPTestCase): def get_app(self): class SmallHeaders(RequestHandler): def get(self): self.set_header("X-Filler", "a" * 100) self.write("ok") class LargeHeaders(RequestHandler): def get(self): self.set_header("X-Filler", "a" * 1000) self.write("ok") return Application([('/small', SmallHeaders), ('/large', LargeHeaders)]) def get_http_client(self): return SimpleAsyncHTTPClient(max_header_size=1024) def test_small_headers(self): response = self.fetch('/small') response.rethrow() self.assertEqual(response.body, b'ok') def test_large_headers(self): with ExpectLog(gen_log, "Unsatisfiable read"): response = self.fetch('/large') self.assertEqual(response.code, 599) class MaxBodySizeTest(AsyncHTTPTestCase): def get_app(self): class SmallBody(RequestHandler): def get(self): self.write("a" * 1024 * 64) class LargeBody(RequestHandler): def get(self): self.write("a" * 1024 * 100) return Application([('/small', SmallBody), ('/large', LargeBody)]) def get_http_client(self): return SimpleAsyncHTTPClient(max_body_size=1024 * 64) def test_small_body(self): response = self.fetch('/small') response.rethrow() self.assertEqual(response.body, b'a' * 1024 * 64) def test_large_body(self): with ExpectLog(gen_log, "Malformed HTTP message from None: Content-Length too long"): response = self.fetch('/large') self.assertEqual(response.code, 599) class MaxBufferSizeTest(AsyncHTTPTestCase): def get_app(self): class LargeBody(RequestHandler): def get(self): self.write("a" * 1024 * 100) return Application([('/large', LargeBody)]) def get_http_client(self): return SimpleAsyncHTTPClient(max_body_size=1024 * 100, max_buffer_size=1024 * 64) def test_large_body(self): response = self.fetch('/large') response.rethrow() self.assertEqual(response.body, b'a' * 1024 * 100) class ChunkedWithContentLengthTest(AsyncHTTPTestCase): def get_app(self): class ChunkedWithContentLength(RequestHandler): def get(self): self.set_header('Transfer-Encoding', 'chunked') self.write("Hello world") return Application([('/chunkwithcl', ChunkedWithContentLength)]) def get_http_client(self): return SimpleAsyncHTTPClient() def test_chunked_with_content_length(self): with ExpectLog(gen_log, ("Malformed HTTP message from None: Response " "with both Transfer-Encoding and Content-Length")): response = self.fetch('/chunkwithcl') self.assertEqual(response.code, 599)

true

f7133411d75ea8e033b78d05fd2b2299db201971

634

py

Python

setup.py

infolabs/django-osme

c0cf7c15dee2b16454461a41316acae2f7c50004

[ "MIT" ]

null

setup.py

infolabs/django-osme

c0cf7c15dee2b16454461a41316acae2f7c50004

[ "MIT" ]

null

setup.py

infolabs/django-osme

c0cf7c15dee2b16454461a41316acae2f7c50004

[ "MIT" ]

1

2022-03-02T07:05:13.000Z

from setuptools import setup, find_packages setup( name='django-osme', version=__import__('osme').__version__, packages=find_packages(), zip_safe=False, install_requires=[ 'Django>=1.9.8', 'requests>=2.23.0', 'jsonfield>=2.1.1', ], package_data={ 'osme': [ 'locale/*/LC_MESSAGES/*', 'static/osme/*', ], }, classifiers=[ 'Environment :: Web Environment', 'Intended Audience :: Developers', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Framework :: Django', ] )

22.642857

45

0.544164

from setuptools import setup, find_packages setup( name='django-osme', version=__import__('osme').__version__, packages=find_packages(), zip_safe=False, install_requires=[ 'Django>=1.9.8', 'requests>=2.23.0', 'jsonfield>=2.1.1', ], package_data={ 'osme': [ 'locale/*/LC_MESSAGES/*', 'static/osme/*', ], }, classifiers=[ 'Environment :: Web Environment', 'Intended Audience :: Developers', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Framework :: Django', ] )

true

f713341ad8ffade2c6c67269c5af51a3bcca148b

2,431

py

Python

database.py

wonabru/chainnet

f8ec1e2b580af837cba3322ffe69b95156b1b9a1

[ "MIT" ]

5

2019-04-20T18:54:55.000Z

2019-08-23T09:17:20.000Z

database.py

wonabru/chainnet

f8ec1e2b580af837cba3322ffe69b95156b1b9a1

[ "MIT" ]

null

database.py

wonabru/chainnet

f8ec1e2b580af837cba3322ffe69b95156b1b9a1

[ "MIT" ]

null

from sqllite import CDataBase as sqllite from kademliaGetSet import CDataBase import socket from isolated_functions import * instance_kade = None class CSQLLite(): def __init__(self): global instance_kade if instance_kade is None: node_identifier = socket.gethostbyname(socket.gethostname()) self.sqllite = sqllite() self.nodes = ["3.113.39.120", "192.168.0.38", "192.168.56.1", "10.0.2.2", "10.0.2.15", "127.0.0.1", node_identifier] self.kade = CDataBase() self.kade.initiate() instance_kade = self else: self.nodes = instance_kade.nodes self.sqllite = instance_kade.sqllite self.kade = instance_kade.kade def save(self, key, value, announce=''): if isinstance(key, str) == False: key = str(key) if announce == 'EXTERNAL': _current = self.sqllite.get(announce) if _current is None: self.sqllite.set(key=announce, value=[key, ]) else: _current.append(key) _current = list(set(_current)) self.sqllite.set(key=announce, value=_current) else: _not_save_local = self.sqllite.get('EXTERNAL') if _not_save_local is None: _not_save_local = [] if not (key in _not_save_local and announce == 'Account:'): self.sqllite.set(key=announce + key, value=value) if announce != '': self.announce(announce + key, value) return self.sqllite.get(announce + key) def get(self, key): if isinstance(key, str) == False: key = str(key) return self.sqllite.get(key=key) def announce(self, key, value): print('KADEMLIA SET: ',key,' = ',self.kade.set(key=key, value=str(value))) def look_at(self, key): if isinstance(key, str) == False: key = str(key) response = self.kade.get(key=key) if response is not None: #self.save(key, response) try: response = str2obj(response) except: pass return response def close(self): self.sqllite.close() def register_node(self, address): if address not in self.nodes: self.nodes.append(address) def bootstrapNodes(self): self.kade.bootstrap(self.nodes)

31.571429

128

0.570136

from sqllite import CDataBase as sqllite from kademliaGetSet import CDataBase import socket from isolated_functions import * instance_kade = None class CSQLLite(): def __init__(self): global instance_kade if instance_kade is None: node_identifier = socket.gethostbyname(socket.gethostname()) self.sqllite = sqllite() self.nodes = ["3.113.39.120", "192.168.0.38", "192.168.56.1", "10.0.2.2", "10.0.2.15", "127.0.0.1", node_identifier] self.kade = CDataBase() self.kade.initiate() instance_kade = self else: self.nodes = instance_kade.nodes self.sqllite = instance_kade.sqllite self.kade = instance_kade.kade def save(self, key, value, announce=''): if isinstance(key, str) == False: key = str(key) if announce == 'EXTERNAL': _current = self.sqllite.get(announce) if _current is None: self.sqllite.set(key=announce, value=[key, ]) else: _current.append(key) _current = list(set(_current)) self.sqllite.set(key=announce, value=_current) else: _not_save_local = self.sqllite.get('EXTERNAL') if _not_save_local is None: _not_save_local = [] if not (key in _not_save_local and announce == 'Account:'): self.sqllite.set(key=announce + key, value=value) if announce != '': self.announce(announce + key, value) return self.sqllite.get(announce + key) def get(self, key): if isinstance(key, str) == False: key = str(key) return self.sqllite.get(key=key) def announce(self, key, value): print('KADEMLIA SET: ',key,' = ',self.kade.set(key=key, value=str(value))) def look_at(self, key): if isinstance(key, str) == False: key = str(key) response = self.kade.get(key=key) if response is not None: try: response = str2obj(response) except: pass return response def close(self): self.sqllite.close() def register_node(self, address): if address not in self.nodes: self.nodes.append(address) def bootstrapNodes(self): self.kade.bootstrap(self.nodes)

true

f713343ad94a8a8448103b68c5a6b512da27982a

1,545

py

Python

src/utils/solvers.py

paul-ang/nas-segm-pytorch

e83704b6cdac6426d6ee51059f82cf650238677c

[ "BSD-2-Clause" ]

155

2019-06-16T03:30:49.000Z

2022-03-17T06:07:33.000Z

src/utils/solvers.py

paul-ang/nas-segm-pytorch

e83704b6cdac6426d6ee51059f82cf650238677c

[ "BSD-2-Clause" ]

7

2019-06-17T03:26:49.000Z

2020-05-24T00:49:17.000Z

src/utils/solvers.py

paul-ang/nas-segm-pytorch

e83704b6cdac6426d6ee51059f82cf650238677c

[ "BSD-2-Clause" ]

29

2019-06-23T07:18:44.000Z

2022-03-17T06:07:34.000Z

"""Initialising Optimisers""" import torch def create_optimisers( optim_enc, optim_dec, lr_enc, lr_dec, mom_enc, mom_dec, wd_enc, wd_dec, param_enc, param_dec, ): """Create optimisers for encoder, decoder Args: optim_enc (str) : type of optimiser for encoder optim_dec (str) : type of optimiser for decoder lr_enc (float) : learning rate for encoder lr_dec (float) : learning rate for decoder mom_enc (float) : momentum for encoder mom_dec (float) : momentum for decoder wd_enc (float) : weight decay for encoder wd_dec (float) : weight decay for decoder param_enc (torch.parameters()) : encoder parameters param_dec (torch.parameters()) : decoder parameters Returns optim_enc, optim_dec (torch.optim) """ if optim_enc == "sgd": optim_enc = torch.optim.SGD( param_enc, lr=lr_enc, momentum=mom_enc, weight_decay=wd_enc ) elif optim_enc == "adam": optim_enc = torch.optim.Adam(param_enc, lr=lr_enc, weight_decay=wd_enc) else: raise ValueError("Unknown Encoder Optimiser: {}".format(optim_enc)) if optim_dec == "sgd": optim_dec = torch.optim.SGD( param_dec, lr=lr_dec, momentum=mom_dec, weight_decay=wd_dec ) elif optim_dec == "adam": optim_dec = torch.optim.Adam(param_dec, lr=lr_dec, weight_decay=wd_dec) else: raise ValueError("Unknown Decoder Optimiser: {}".format(optim_dec)) return optim_enc, optim_dec

29.150943

79

0.650485

import torch def create_optimisers( optim_enc, optim_dec, lr_enc, lr_dec, mom_enc, mom_dec, wd_enc, wd_dec, param_enc, param_dec, ): if optim_enc == "sgd": optim_enc = torch.optim.SGD( param_enc, lr=lr_enc, momentum=mom_enc, weight_decay=wd_enc ) elif optim_enc == "adam": optim_enc = torch.optim.Adam(param_enc, lr=lr_enc, weight_decay=wd_enc) else: raise ValueError("Unknown Encoder Optimiser: {}".format(optim_enc)) if optim_dec == "sgd": optim_dec = torch.optim.SGD( param_dec, lr=lr_dec, momentum=mom_dec, weight_decay=wd_dec ) elif optim_dec == "adam": optim_dec = torch.optim.Adam(param_dec, lr=lr_dec, weight_decay=wd_dec) else: raise ValueError("Unknown Decoder Optimiser: {}".format(optim_dec)) return optim_enc, optim_dec

true

f71334a6c255d3ef0f685aa8bc1c31bfe8861d8c

4,301

py

Python

IPython/frontend/qt/console/tests/test_ansi_code_processor.py

tinyclues/ipython

71e32606b0242772b81c9be0d40751ba47d95f2c

[ "BSD-3-Clause-Clear" ]

2

2015-04-21T12:12:43.000Z

2015-04-21T12:12:54.000Z

IPython/frontend/qt/console/tests/test_ansi_code_processor.py

adgaudio/ipython

a924f50c0f7b84127391f1c396326258c2b303e2

[ "BSD-3-Clause-Clear" ]

1

2015-07-16T22:26:53.000Z

IPython/frontend/qt/console/tests/test_ansi_code_processor.py

adgaudio/ipython

a924f50c0f7b84127391f1c396326258c2b303e2

[ "BSD-3-Clause-Clear" ]

null

# Standard library imports import unittest # Local imports from IPython.frontend.qt.console.ansi_code_processor import AnsiCodeProcessor class TestAnsiCodeProcessor(unittest.TestCase): def setUp(self): self.processor = AnsiCodeProcessor() def test_clear(self): """ Do control sequences for clearing the console work? """ string = '\x1b[2J\x1b[K' i = -1 for i, substring in enumerate(self.processor.split_string(string)): if i == 0: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'erase') self.assertEquals(action.area, 'screen') self.assertEquals(action.erase_to, 'all') elif i == 1: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'erase') self.assertEquals(action.area, 'line') self.assertEquals(action.erase_to, 'end') else: self.fail('Too many substrings.') self.assertEquals(i, 1, 'Too few substrings.') def test_colors(self): """ Do basic controls sequences for colors work? """ string = 'first\x1b[34mblue\x1b[0mlast' i = -1 for i, substring in enumerate(self.processor.split_string(string)): if i == 0: self.assertEquals(substring, 'first') self.assertEquals(self.processor.foreground_color, None) elif i == 1: self.assertEquals(substring, 'blue') self.assertEquals(self.processor.foreground_color, 4) elif i == 2: self.assertEquals(substring, 'last') self.assertEquals(self.processor.foreground_color, None) else: self.fail('Too many substrings.') self.assertEquals(i, 2, 'Too few substrings.') def test_colors_xterm(self): """ Do xterm-specific control sequences for colors work? """ string = '\x1b]4;20;rgb:ff/ff/ff\x1b' \ '\x1b]4;25;rgbi:1.0/1.0/1.0\x1b' substrings = list(self.processor.split_string(string)) desired = { 20 : (255, 255, 255), 25 : (255, 255, 255) } self.assertEquals(self.processor.color_map, desired) string = '\x1b[38;5;20m\x1b[48;5;25m' substrings = list(self.processor.split_string(string)) self.assertEquals(self.processor.foreground_color, 20) self.assertEquals(self.processor.background_color, 25) def test_scroll(self): """ Do control sequences for scrolling the buffer work? """ string = '\x1b[5S\x1b[T' i = -1 for i, substring in enumerate(self.processor.split_string(string)): if i == 0: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'scroll') self.assertEquals(action.dir, 'up') self.assertEquals(action.unit, 'line') self.assertEquals(action.count, 5) elif i == 1: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'scroll') self.assertEquals(action.dir, 'down') self.assertEquals(action.unit, 'line') self.assertEquals(action.count, 1) else: self.fail('Too many substrings.') self.assertEquals(i, 1, 'Too few substrings.') def test_specials(self): """ Are special characters processed correctly? """ string = '\f' # form feed self.assertEquals(list(self.processor.split_string(string)), ['']) self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'scroll') self.assertEquals(action.dir, 'down') self.assertEquals(action.unit, 'page') self.assertEquals(action.count, 1) if __name__ == '__main__': unittest.main()

39.824074

77

0.581958

import unittest from IPython.frontend.qt.console.ansi_code_processor import AnsiCodeProcessor class TestAnsiCodeProcessor(unittest.TestCase): def setUp(self): self.processor = AnsiCodeProcessor() def test_clear(self): string = '\x1b[2J\x1b[K' i = -1 for i, substring in enumerate(self.processor.split_string(string)): if i == 0: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'erase') self.assertEquals(action.area, 'screen') self.assertEquals(action.erase_to, 'all') elif i == 1: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'erase') self.assertEquals(action.area, 'line') self.assertEquals(action.erase_to, 'end') else: self.fail('Too many substrings.') self.assertEquals(i, 1, 'Too few substrings.') def test_colors(self): string = 'first\x1b[34mblue\x1b[0mlast' i = -1 for i, substring in enumerate(self.processor.split_string(string)): if i == 0: self.assertEquals(substring, 'first') self.assertEquals(self.processor.foreground_color, None) elif i == 1: self.assertEquals(substring, 'blue') self.assertEquals(self.processor.foreground_color, 4) elif i == 2: self.assertEquals(substring, 'last') self.assertEquals(self.processor.foreground_color, None) else: self.fail('Too many substrings.') self.assertEquals(i, 2, 'Too few substrings.') def test_colors_xterm(self): string = '\x1b]4;20;rgb:ff/ff/ff\x1b' \ '\x1b]4;25;rgbi:1.0/1.0/1.0\x1b' substrings = list(self.processor.split_string(string)) desired = { 20 : (255, 255, 255), 25 : (255, 255, 255) } self.assertEquals(self.processor.color_map, desired) string = '\x1b[38;5;20m\x1b[48;5;25m' substrings = list(self.processor.split_string(string)) self.assertEquals(self.processor.foreground_color, 20) self.assertEquals(self.processor.background_color, 25) def test_scroll(self): string = '\x1b[5S\x1b[T' i = -1 for i, substring in enumerate(self.processor.split_string(string)): if i == 0: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'scroll') self.assertEquals(action.dir, 'up') self.assertEquals(action.unit, 'line') self.assertEquals(action.count, 5) elif i == 1: self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'scroll') self.assertEquals(action.dir, 'down') self.assertEquals(action.unit, 'line') self.assertEquals(action.count, 1) else: self.fail('Too many substrings.') self.assertEquals(i, 1, 'Too few substrings.') def test_specials(self): string = '\f' self.assertEquals(list(self.processor.split_string(string)), ['']) self.assertEquals(len(self.processor.actions), 1) action = self.processor.actions[0] self.assertEquals(action.action, 'scroll') self.assertEquals(action.dir, 'down') self.assertEquals(action.unit, 'page') self.assertEquals(action.count, 1) if __name__ == '__main__': unittest.main()

true

f7133538bfaf31e38373cd86c3401cac5bc8ab30

5,181

py

Python

desktop/core/ext-py/ctypes-1.0.2/ctypes/util.py

erickt/hue

a046f1dd21226689ed447422f3373d96c65b2fd2

[ "Apache-2.0" ]

19

2015-05-01T19:59:03.000Z

2021-12-09T08:03:16.000Z

desktop/core/ext-py/ctypes-1.0.2/ctypes/util.py

erickt/hue

a046f1dd21226689ed447422f3373d96c65b2fd2

[ "Apache-2.0" ]

1

2018-01-03T15:26:49.000Z

desktop/core/ext-py/ctypes-1.0.2/ctypes/util.py

erickt/hue

a046f1dd21226689ed447422f3373d96c65b2fd2

[ "Apache-2.0" ]

30

2015-03-25T19:40:07.000Z

2021-05-28T22:59:26.000Z

###################################################################### # This file should be kept compatible with Python 2.3, see PEP 291. # ###################################################################### import sys, os # find_library(name) returns the pathname of a library, or None. if os.name == "nt": def find_library(name): # See MSDN for the REAL search order. for directory in os.environ['PATH'].split(os.pathsep): fname = os.path.join(directory, name) if os.path.exists(fname): return fname if fname.lower().endswith(".dll"): continue fname = fname + ".dll" if os.path.exists(fname): return fname return None if os.name == "ce": # search path according to MSDN: # - absolute path specified by filename # - The .exe launch directory # - the Windows directory # - ROM dll files (where are they?) # - OEM specified search path: HKLM\Loader\SystemPath def find_library(name): return name if os.name == "posix" and sys.platform == "darwin": from ctypes.macholib.dyld import dyld_find as _dyld_find def find_library(name): possible = ['lib%s.dylib' % name, '%s.dylib' % name, '%s.framework/%s' % (name, name)] for name in possible: try: return _dyld_find(name) except ValueError: continue return None elif os.name == "posix": # Andreas Degert's find functions, using gcc, /sbin/ldconfig, objdump import re, tempfile, errno def _findLib_gcc(name): expr = r'[^\s]*lib%s\.[^\s]*' % re.escape(name) fdout, ccout = tempfile.mkstemp() os.close(fdout) cmd = 'if type gcc >/dev/null 2>&1; then CC=gcc; else CC=cc; fi;' \ '$CC -Wl,-t -o ' + ccout + ' 2>&1 -l' + name try: f = os.popen(cmd) trace = f.read() f.close() finally: try: os.unlink(ccout) except OSError, e: if e.errno != errno.ENOENT: raise res = re.search(expr, trace) if not res: return None return res.group(0) def _get_soname(f): # assuming GNU binutils / ELF if not f: return None cmd = "objdump -p -j .dynamic 2>/dev/null " + f res = re.search(r'\sSONAME\s+([^\s]+)', os.popen(cmd).read()) if not res: return None return res.group(1) if (sys.platform.startswith("freebsd") or sys.platform.startswith("openbsd") or sys.platform.startswith("dragonfly")): def _num_version(libname): # "libxyz.so.MAJOR.MINOR" => [ MAJOR, MINOR ] parts = libname.split(".") nums = [] try: while parts: nums.insert(0, int(parts.pop())) except ValueError: pass return nums or [ sys.maxint ] def find_library(name): ename = re.escape(name) expr = r':-l%s\.\S+ => \S*/(lib%s\.\S+)' % (ename, ename) res = re.findall(expr, os.popen('/sbin/ldconfig -r 2>/dev/null').read()) if not res: return _get_soname(_findLib_gcc(name)) res.sort(cmp= lambda x,y: cmp(_num_version(x), _num_version(y))) return res[-1] else: def _findLib_ldconfig(name): # XXX assuming GLIBC's ldconfig (with option -p) expr = r'/[^\s]*lib%s\.[^\s]*' % re.escape(name) res = re.search(expr, os.popen('/sbin/ldconfig -p 2>/dev/null').read()) if not res: # Hm, this works only for libs needed by the python executable. cmd = 'ldd %s 2>/dev/null' % sys.executable res = re.search(expr, os.popen(cmd).read()) if not res: return None return res.group(0) def find_library(name): return _get_soname(_findLib_ldconfig(name) or _findLib_gcc(name)) ################################################################ # test code def test(): from ctypes import cdll if os.name == "nt": print cdll.msvcrt print cdll.load("msvcrt") print find_library("msvcrt") if os.name == "posix": # find and load_version print find_library("m") print find_library("c") print find_library("bz2") # getattr ## print cdll.m ## print cdll.bz2 # load if sys.platform == "darwin": print cdll.LoadLibrary("libm.dylib") print cdll.LoadLibrary("libcrypto.dylib") print cdll.LoadLibrary("libSystem.dylib") print cdll.LoadLibrary("System.framework/System") else: print cdll.LoadLibrary("libm.so") print cdll.LoadLibrary("libcrypt.so") print find_library("crypt") if __name__ == "__main__": test()

33.425806

79

0.498359

false

true

f7133649eb9a45a5364a31adeffb80967133f93b

12,144

py

Python

sdk/python/pulumi_google_native/compute/v1/get_global_address.py

AaronFriel/pulumi-google-native

75d1cda425e33d4610348972cd70bddf35f1770d

[ "Apache-2.0" ]

44

2021-04-18T23:00:48.000Z

2022-02-14T17:43:15.000Z

sdk/python/pulumi_google_native/compute/v1/get_global_address.py

AaronFriel/pulumi-google-native

75d1cda425e33d4610348972cd70bddf35f1770d

[ "Apache-2.0" ]

354

2021-04-16T16:48:39.000Z

2022-03-31T17:16:39.000Z

sdk/python/pulumi_google_native/compute/v1/get_global_address.py

AaronFriel/pulumi-google-native

75d1cda425e33d4610348972cd70bddf35f1770d

[ "Apache-2.0" ]

8

2021-04-24T17:46:51.000Z

2022-01-05T10:40:21.000Z

# 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 __all__ = [ 'GetGlobalAddressResult', 'AwaitableGetGlobalAddressResult', 'get_global_address', 'get_global_address_output', ] @pulumi.output_type class GetGlobalAddressResult: def __init__(__self__, address=None, address_type=None, creation_timestamp=None, description=None, ip_version=None, kind=None, name=None, network=None, network_tier=None, prefix_length=None, purpose=None, region=None, self_link=None, status=None, subnetwork=None, users=None): if address and not isinstance(address, str): raise TypeError("Expected argument 'address' to be a str") pulumi.set(__self__, "address", address) if address_type and not isinstance(address_type, str): raise TypeError("Expected argument 'address_type' to be a str") pulumi.set(__self__, "address_type", address_type) if creation_timestamp and not isinstance(creation_timestamp, str): raise TypeError("Expected argument 'creation_timestamp' to be a str") pulumi.set(__self__, "creation_timestamp", creation_timestamp) if description and not isinstance(description, str): raise TypeError("Expected argument 'description' to be a str") pulumi.set(__self__, "description", description) if ip_version and not isinstance(ip_version, str): raise TypeError("Expected argument 'ip_version' to be a str") pulumi.set(__self__, "ip_version", ip_version) if kind and not isinstance(kind, str): raise TypeError("Expected argument 'kind' to be a str") pulumi.set(__self__, "kind", kind) if name and not isinstance(name, str): raise TypeError("Expected argument 'name' to be a str") pulumi.set(__self__, "name", name) if network and not isinstance(network, str): raise TypeError("Expected argument 'network' to be a str") pulumi.set(__self__, "network", network) if network_tier and not isinstance(network_tier, str): raise TypeError("Expected argument 'network_tier' to be a str") pulumi.set(__self__, "network_tier", network_tier) if prefix_length and not isinstance(prefix_length, int): raise TypeError("Expected argument 'prefix_length' to be a int") pulumi.set(__self__, "prefix_length", prefix_length) if purpose and not isinstance(purpose, str): raise TypeError("Expected argument 'purpose' to be a str") pulumi.set(__self__, "purpose", purpose) if region and not isinstance(region, str): raise TypeError("Expected argument 'region' to be a str") pulumi.set(__self__, "region", region) if self_link and not isinstance(self_link, str): raise TypeError("Expected argument 'self_link' to be a str") pulumi.set(__self__, "self_link", self_link) if status and not isinstance(status, str): raise TypeError("Expected argument 'status' to be a str") pulumi.set(__self__, "status", status) if subnetwork and not isinstance(subnetwork, str): raise TypeError("Expected argument 'subnetwork' to be a str") pulumi.set(__self__, "subnetwork", subnetwork) if users and not isinstance(users, list): raise TypeError("Expected argument 'users' to be a list") pulumi.set(__self__, "users", users) @property @pulumi.getter def address(self) -> str: """ The static IP address represented by this resource. """ return pulumi.get(self, "address") @property @pulumi.getter(name="addressType") def address_type(self) -> str: """ The type of address to reserve, either INTERNAL or EXTERNAL. If unspecified, defaults to EXTERNAL. """ return pulumi.get(self, "address_type") @property @pulumi.getter(name="creationTimestamp") def creation_timestamp(self) -> str: """ Creation timestamp in RFC3339 text format. """ return pulumi.get(self, "creation_timestamp") @property @pulumi.getter def description(self) -> str: """ An optional description of this resource. Provide this field when you create the resource. """ return pulumi.get(self, "description") @property @pulumi.getter(name="ipVersion") def ip_version(self) -> str: """ The IP version that will be used by this address. Valid options are IPV4 or IPV6. This can only be specified for a global address. """ return pulumi.get(self, "ip_version") @property @pulumi.getter def kind(self) -> str: """ Type of the resource. Always compute#address for addresses. """ return pulumi.get(self, "kind") @property @pulumi.getter def name(self) -> str: """ Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?`. The first character must be a lowercase letter, and all following characters (except for the last character) must be a dash, lowercase letter, or digit. The last character must be a lowercase letter or digit. """ return pulumi.get(self, "name") @property @pulumi.getter def network(self) -> str: """ The URL of the network in which to reserve the address. This field can only be used with INTERNAL type with the VPC_PEERING purpose. """ return pulumi.get(self, "network") @property @pulumi.getter(name="networkTier") def network_tier(self) -> str: """ This signifies the networking tier used for configuring this address and can only take the following values: PREMIUM or STANDARD. Internal IP addresses are always Premium Tier; global external IP addresses are always Premium Tier; regional external IP addresses can be either Standard or Premium Tier. If this field is not specified, it is assumed to be PREMIUM. """ return pulumi.get(self, "network_tier") @property @pulumi.getter(name="prefixLength") def prefix_length(self) -> int: """ The prefix length if the resource represents an IP range. """ return pulumi.get(self, "prefix_length") @property @pulumi.getter def purpose(self) -> str: """ The purpose of this resource, which can be one of the following values: - GCE_ENDPOINT for addresses that are used by VM instances, alias IP ranges, load balancers, and similar resources. - DNS_RESOLVER for a DNS resolver address in a subnetwork for a Cloud DNS inbound forwarder IP addresses (regional internal IP address in a subnet of a VPC network) - VPC_PEERING for global internal IP addresses used for private services access allocated ranges. - NAT_AUTO for the regional external IP addresses used by Cloud NAT when allocating addresses using automatic NAT IP address allocation. - IPSEC_INTERCONNECT for addresses created from a private IP range that are reserved for a VLAN attachment in an *IPsec-encrypted Cloud Interconnect* configuration. These addresses are regional resources. Not currently available publicly. - `SHARED_LOADBALANCER_VIP` for an internal IP address that is assigned to multiple internal forwarding rules. - `PRIVATE_SERVICE_CONNECT` for a private network address that is used to configure Private Service Connect. Only global internal addresses can use this purpose. """ return pulumi.get(self, "purpose") @property @pulumi.getter def region(self) -> str: """ The URL of the region where a regional address resides. For regional addresses, you must specify the region as a path parameter in the HTTP request URL. *This field is not applicable to global addresses.* """ return pulumi.get(self, "region") @property @pulumi.getter(name="selfLink") def self_link(self) -> str: """ Server-defined URL for the resource. """ return pulumi.get(self, "self_link") @property @pulumi.getter def status(self) -> str: """ The status of the address, which can be one of RESERVING, RESERVED, or IN_USE. An address that is RESERVING is currently in the process of being reserved. A RESERVED address is currently reserved and available to use. An IN_USE address is currently being used by another resource and is not available. """ return pulumi.get(self, "status") @property @pulumi.getter def subnetwork(self) -> str: """ The URL of the subnetwork in which to reserve the address. If an IP address is specified, it must be within the subnetwork's IP range. This field can only be used with INTERNAL type with a GCE_ENDPOINT or DNS_RESOLVER purpose. """ return pulumi.get(self, "subnetwork") @property @pulumi.getter def users(self) -> Sequence[str]: """ The URLs of the resources that are using this address. """ return pulumi.get(self, "users") class AwaitableGetGlobalAddressResult(GetGlobalAddressResult): # pylint: disable=using-constant-test def __await__(self): if False: yield self return GetGlobalAddressResult( address=self.address, address_type=self.address_type, creation_timestamp=self.creation_timestamp, description=self.description, ip_version=self.ip_version, kind=self.kind, name=self.name, network=self.network, network_tier=self.network_tier, prefix_length=self.prefix_length, purpose=self.purpose, region=self.region, self_link=self.self_link, status=self.status, subnetwork=self.subnetwork, users=self.users) def get_global_address(address: Optional[str] = None, project: Optional[str] = None, opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGlobalAddressResult: """ Returns the specified address resource. Gets a list of available addresses by making a list() request. """ __args__ = dict() __args__['address'] = address __args__['project'] = project if opts is None: opts = pulumi.InvokeOptions() if opts.version is None: opts.version = _utilities.get_version() __ret__ = pulumi.runtime.invoke('google-native:compute/v1:getGlobalAddress', __args__, opts=opts, typ=GetGlobalAddressResult).value return AwaitableGetGlobalAddressResult( address=__ret__.address, address_type=__ret__.address_type, creation_timestamp=__ret__.creation_timestamp, description=__ret__.description, ip_version=__ret__.ip_version, kind=__ret__.kind, name=__ret__.name, network=__ret__.network, network_tier=__ret__.network_tier, prefix_length=__ret__.prefix_length, purpose=__ret__.purpose, region=__ret__.region, self_link=__ret__.self_link, status=__ret__.status, subnetwork=__ret__.subnetwork, users=__ret__.users) @_utilities.lift_output_func(get_global_address) def get_global_address_output(address: Optional[pulumi.Input[str]] = None, project: Optional[pulumi.Input[Optional[str]]] = None, opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetGlobalAddressResult]: """ Returns the specified address resource. Gets a list of available addresses by making a list() request. """ ...

45.826415

1,108

0.670866

import warnings import pulumi import pulumi.runtime from typing import Any, Mapping, Optional, Sequence, Union, overload from ... import _utilities __all__ = [ 'GetGlobalAddressResult', 'AwaitableGetGlobalAddressResult', 'get_global_address', 'get_global_address_output', ] @pulumi.output_type class GetGlobalAddressResult: def __init__(__self__, address=None, address_type=None, creation_timestamp=None, description=None, ip_version=None, kind=None, name=None, network=None, network_tier=None, prefix_length=None, purpose=None, region=None, self_link=None, status=None, subnetwork=None, users=None): if address and not isinstance(address, str): raise TypeError("Expected argument 'address' to be a str") pulumi.set(__self__, "address", address) if address_type and not isinstance(address_type, str): raise TypeError("Expected argument 'address_type' to be a str") pulumi.set(__self__, "address_type", address_type) if creation_timestamp and not isinstance(creation_timestamp, str): raise TypeError("Expected argument 'creation_timestamp' to be a str") pulumi.set(__self__, "creation_timestamp", creation_timestamp) if description and not isinstance(description, str): raise TypeError("Expected argument 'description' to be a str") pulumi.set(__self__, "description", description) if ip_version and not isinstance(ip_version, str): raise TypeError("Expected argument 'ip_version' to be a str") pulumi.set(__self__, "ip_version", ip_version) if kind and not isinstance(kind, str): raise TypeError("Expected argument 'kind' to be a str") pulumi.set(__self__, "kind", kind) if name and not isinstance(name, str): raise TypeError("Expected argument 'name' to be a str") pulumi.set(__self__, "name", name) if network and not isinstance(network, str): raise TypeError("Expected argument 'network' to be a str") pulumi.set(__self__, "network", network) if network_tier and not isinstance(network_tier, str): raise TypeError("Expected argument 'network_tier' to be a str") pulumi.set(__self__, "network_tier", network_tier) if prefix_length and not isinstance(prefix_length, int): raise TypeError("Expected argument 'prefix_length' to be a int") pulumi.set(__self__, "prefix_length", prefix_length) if purpose and not isinstance(purpose, str): raise TypeError("Expected argument 'purpose' to be a str") pulumi.set(__self__, "purpose", purpose) if region and not isinstance(region, str): raise TypeError("Expected argument 'region' to be a str") pulumi.set(__self__, "region", region) if self_link and not isinstance(self_link, str): raise TypeError("Expected argument 'self_link' to be a str") pulumi.set(__self__, "self_link", self_link) if status and not isinstance(status, str): raise TypeError("Expected argument 'status' to be a str") pulumi.set(__self__, "status", status) if subnetwork and not isinstance(subnetwork, str): raise TypeError("Expected argument 'subnetwork' to be a str") pulumi.set(__self__, "subnetwork", subnetwork) if users and not isinstance(users, list): raise TypeError("Expected argument 'users' to be a list") pulumi.set(__self__, "users", users) @property @pulumi.getter def address(self) -> str: return pulumi.get(self, "address") @property @pulumi.getter(name="addressType") def address_type(self) -> str: return pulumi.get(self, "address_type") @property @pulumi.getter(name="creationTimestamp") def creation_timestamp(self) -> str: return pulumi.get(self, "creation_timestamp") @property @pulumi.getter def description(self) -> str: return pulumi.get(self, "description") @property @pulumi.getter(name="ipVersion") def ip_version(self) -> str: return pulumi.get(self, "ip_version") @property @pulumi.getter def kind(self) -> str: return pulumi.get(self, "kind") @property @pulumi.getter def name(self) -> str: return pulumi.get(self, "name") @property @pulumi.getter def network(self) -> str: return pulumi.get(self, "network") @property @pulumi.getter(name="networkTier") def network_tier(self) -> str: return pulumi.get(self, "network_tier") @property @pulumi.getter(name="prefixLength") def prefix_length(self) -> int: return pulumi.get(self, "prefix_length") @property @pulumi.getter def purpose(self) -> str: return pulumi.get(self, "purpose") @property @pulumi.getter def region(self) -> str: return pulumi.get(self, "region") @property @pulumi.getter(name="selfLink") def self_link(self) -> str: return pulumi.get(self, "self_link") @property @pulumi.getter def status(self) -> str: return pulumi.get(self, "status") @property @pulumi.getter def subnetwork(self) -> str: return pulumi.get(self, "subnetwork") @property @pulumi.getter def users(self) -> Sequence[str]: return pulumi.get(self, "users") class AwaitableGetGlobalAddressResult(GetGlobalAddressResult): # pylint: disable=using-constant-test def __await__(self): if False: yield self return GetGlobalAddressResult( address=self.address, address_type=self.address_type, creation_timestamp=self.creation_timestamp, description=self.description, ip_version=self.ip_version, kind=self.kind, name=self.name, network=self.network, network_tier=self.network_tier, prefix_length=self.prefix_length, purpose=self.purpose, region=self.region, self_link=self.self_link, status=self.status, subnetwork=self.subnetwork, users=self.users) def get_global_address(address: Optional[str] = None, project: Optional[str] = None, opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGlobalAddressResult: __args__ = dict() __args__['address'] = address __args__['project'] = project if opts is None: opts = pulumi.InvokeOptions() if opts.version is None: opts.version = _utilities.get_version() __ret__ = pulumi.runtime.invoke('google-native:compute/v1:getGlobalAddress', __args__, opts=opts, typ=GetGlobalAddressResult).value return AwaitableGetGlobalAddressResult( address=__ret__.address, address_type=__ret__.address_type, creation_timestamp=__ret__.creation_timestamp, description=__ret__.description, ip_version=__ret__.ip_version, kind=__ret__.kind, name=__ret__.name, network=__ret__.network, network_tier=__ret__.network_tier, prefix_length=__ret__.prefix_length, purpose=__ret__.purpose, region=__ret__.region, self_link=__ret__.self_link, status=__ret__.status, subnetwork=__ret__.subnetwork, users=__ret__.users) @_utilities.lift_output_func(get_global_address) def get_global_address_output(address: Optional[pulumi.Input[str]] = None, project: Optional[pulumi.Input[Optional[str]]] = None, opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetGlobalAddressResult]: ...

true

f713384b5e89b13964f1b7a6a23cfc6caab01cd7

6,903

py

Python

deeppavlov_agent/http_api/handlers.py

deepmipt/dp-agent

74b5b993a451ac54efd9a5086ff507a9520ad0c6

[ "Apache-2.0" ]

54

2019-05-16T12:58:54.000Z

2022-01-09T06:09:01.000Z

deeppavlov_agent/http_api/handlers.py

deepmipt/dp-agent

74b5b993a451ac54efd9a5086ff507a9520ad0c6

[ "Apache-2.0" ]

27

2019-06-13T12:31:42.000Z

2021-09-10T16:37:59.000Z

deeppavlov_agent/http_api/handlers.py

deepmipt/dp-agent

74b5b993a451ac54efd9a5086ff507a9520ad0c6

[ "Apache-2.0" ]

25

2019-06-08T03:30:48.000Z

2022-03-17T15:47:27.000Z

import asyncio from datetime import datetime from string import hexdigits from time import time import aiohttp import aiohttp_jinja2 from aiohttp import web async def handle_command(payload, user_id, state_manager): if payload in {'/start', '/close'} and state_manager: await state_manager.drop_active_dialog(user_id) return True class ApiHandler: def __init__(self, output_formatter, response_time_limit=5): self.output_formatter = output_formatter self.response_time_limit = response_time_limit async def handle_api_request(self, request): response = {} register_msg = request.app['agent'].register_msg if request.method == 'POST': if 'content-type' not in request.headers \ or not request.headers['content-type'].startswith('application/json'): raise web.HTTPBadRequest(reason='Content-Type should be application/json') data = await request.json() user_id = data.pop('user_id') payload = data.pop('payload', '') deadline_timestamp = None if self.response_time_limit: deadline_timestamp = time() + self.response_time_limit if not user_id: raise web.HTTPBadRequest(reason='user_id key is required') command_performed = await handle_command(payload, user_id, request.app['agent'].state_manager) if command_performed: return web.json_response({}) response = await asyncio.shield( register_msg(utterance=payload, user_external_id=user_id, user_device_type=data.pop('user_device_type', 'http'), date_time=datetime.now(), location=data.pop('location', ''), channel_type='http_client', message_attrs=data, require_response=True, deadline_timestamp=deadline_timestamp) ) if response is None: raise RuntimeError('Got None instead of a bot response.') return web.json_response(self.output_formatter(response['dialog'].to_dict())) async def dialog(self, request): state_manager = request.app['agent'].state_manager dialog_id = request.match_info['dialog_id'] if len(dialog_id) == 24 and all(c in hexdigits for c in dialog_id): dialog_obj = await state_manager.get_dialog_by_id(dialog_id) if not dialog_obj: raise web.HTTPNotFound(reason=f'dialog with id {dialog_id} does not exist') return web.json_response(dialog_obj.to_dict()) raise web.HTTPBadRequest(reason='dialog id should be 24-character hex string') async def dialogs_by_user(self, request): state_manager = request.app['agent'].state_manager user_external_id = request.match_info['user_external_id'] dialogs = await state_manager.get_dialogs_by_user_ext_id(user_external_id) return web.json_response([i.to_dict() for i in dialogs]) async def dialog_rating(self, request): state_manager = request.app['agent'].state_manager data = await request.json() dialog_id = data.pop('dialog_id') user_id = data.pop('user_id', None) rating = data.pop('rating') await state_manager.set_rating_dialog(user_id, dialog_id, rating) return web.Response() async def utterance_rating(self, request): state_manager = request.app['agent'].state_manager data = await request.json() user_id = data.pop('user_id', None) rating = data.pop('rating') utt_id = data.pop('utt_id') await state_manager.set_rating_utterance(user_id, utt_id, rating) return web.Response() async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'POST, OPTIONS'}) class PagesHandler: def __init__(self, debug=False): self.debug = debug async def ping(self, request): return web.json_response("pong") async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'GET, OPTIONS'}) class WSstatsHandler: def __init__(self): self.update_time = 0.5 @aiohttp_jinja2.template('services_ws_highcharts.html') async def ws_page(self, request): return {} async def ws_handler(self, request): ws = web.WebSocketResponse() await ws.prepare(request) request.app['websockets'].append(ws) logger_stats = request.app['logger_stats'] while True: data = dict(logger_stats.get_current_load()) await ws.send_json(data) await asyncio.sleep(self.update_time) return ws async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'GET, OPTIONS'}) class WSChatHandler: def __init__(self, output_formatter): self.output_formatter = output_formatter @aiohttp_jinja2.template('chat.html') async def ws_page(self, request): return {} async def ws_handler(self, request): register_msg = request.app['agent'].register_msg ws = web.WebSocketResponse() await ws.prepare(request) while True: msg = await ws.receive() if msg.type == aiohttp.WSMsgType.text: data = msg.json() user_id = data.pop('user_id') payload = data.pop('payload', '') deadline_timestamp = None if not user_id: raise web.HTTPBadRequest(reason='user_id key is required') command_performed = await handle_command(payload, user_id, request.app['agent'].state_manager) if command_performed: await ws.send_json('command_performed') continue response = await register_msg( utterance=payload, user_external_id=user_id, user_device_type=data.pop('user_device_type', 'websocket'), date_time=datetime.now(), location=data.pop('location', ''), channel_type='ws_client', message_attrs=data, require_response=True, deadline_timestamp=deadline_timestamp ) if response is None: raise RuntimeError('Got None instead of a bot response.') await ws.send_json(self.output_formatter(response['dialog'].to_dict())) else: await ws.close() break return ws async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'GET, OPTIONS'})

38.564246

110

0.618282

import asyncio from datetime import datetime from string import hexdigits from time import time import aiohttp import aiohttp_jinja2 from aiohttp import web async def handle_command(payload, user_id, state_manager): if payload in {'/start', '/close'} and state_manager: await state_manager.drop_active_dialog(user_id) return True class ApiHandler: def __init__(self, output_formatter, response_time_limit=5): self.output_formatter = output_formatter self.response_time_limit = response_time_limit async def handle_api_request(self, request): response = {} register_msg = request.app['agent'].register_msg if request.method == 'POST': if 'content-type' not in request.headers \ or not request.headers['content-type'].startswith('application/json'): raise web.HTTPBadRequest(reason='Content-Type should be application/json') data = await request.json() user_id = data.pop('user_id') payload = data.pop('payload', '') deadline_timestamp = None if self.response_time_limit: deadline_timestamp = time() + self.response_time_limit if not user_id: raise web.HTTPBadRequest(reason='user_id key is required') command_performed = await handle_command(payload, user_id, request.app['agent'].state_manager) if command_performed: return web.json_response({}) response = await asyncio.shield( register_msg(utterance=payload, user_external_id=user_id, user_device_type=data.pop('user_device_type', 'http'), date_time=datetime.now(), location=data.pop('location', ''), channel_type='http_client', message_attrs=data, require_response=True, deadline_timestamp=deadline_timestamp) ) if response is None: raise RuntimeError('Got None instead of a bot response.') return web.json_response(self.output_formatter(response['dialog'].to_dict())) async def dialog(self, request): state_manager = request.app['agent'].state_manager dialog_id = request.match_info['dialog_id'] if len(dialog_id) == 24 and all(c in hexdigits for c in dialog_id): dialog_obj = await state_manager.get_dialog_by_id(dialog_id) if not dialog_obj: raise web.HTTPNotFound(reason=f'dialog with id {dialog_id} does not exist') return web.json_response(dialog_obj.to_dict()) raise web.HTTPBadRequest(reason='dialog id should be 24-character hex string') async def dialogs_by_user(self, request): state_manager = request.app['agent'].state_manager user_external_id = request.match_info['user_external_id'] dialogs = await state_manager.get_dialogs_by_user_ext_id(user_external_id) return web.json_response([i.to_dict() for i in dialogs]) async def dialog_rating(self, request): state_manager = request.app['agent'].state_manager data = await request.json() dialog_id = data.pop('dialog_id') user_id = data.pop('user_id', None) rating = data.pop('rating') await state_manager.set_rating_dialog(user_id, dialog_id, rating) return web.Response() async def utterance_rating(self, request): state_manager = request.app['agent'].state_manager data = await request.json() user_id = data.pop('user_id', None) rating = data.pop('rating') utt_id = data.pop('utt_id') await state_manager.set_rating_utterance(user_id, utt_id, rating) return web.Response() async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'POST, OPTIONS'}) class PagesHandler: def __init__(self, debug=False): self.debug = debug async def ping(self, request): return web.json_response("pong") async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'GET, OPTIONS'}) class WSstatsHandler: def __init__(self): self.update_time = 0.5 @aiohttp_jinja2.template('services_ws_highcharts.html') async def ws_page(self, request): return {} async def ws_handler(self, request): ws = web.WebSocketResponse() await ws.prepare(request) request.app['websockets'].append(ws) logger_stats = request.app['logger_stats'] while True: data = dict(logger_stats.get_current_load()) await ws.send_json(data) await asyncio.sleep(self.update_time) return ws async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'GET, OPTIONS'}) class WSChatHandler: def __init__(self, output_formatter): self.output_formatter = output_formatter @aiohttp_jinja2.template('chat.html') async def ws_page(self, request): return {} async def ws_handler(self, request): register_msg = request.app['agent'].register_msg ws = web.WebSocketResponse() await ws.prepare(request) while True: msg = await ws.receive() if msg.type == aiohttp.WSMsgType.text: data = msg.json() user_id = data.pop('user_id') payload = data.pop('payload', '') deadline_timestamp = None if not user_id: raise web.HTTPBadRequest(reason='user_id key is required') command_performed = await handle_command(payload, user_id, request.app['agent'].state_manager) if command_performed: await ws.send_json('command_performed') continue response = await register_msg( utterance=payload, user_external_id=user_id, user_device_type=data.pop('user_device_type', 'websocket'), date_time=datetime.now(), location=data.pop('location', ''), channel_type='ws_client', message_attrs=data, require_response=True, deadline_timestamp=deadline_timestamp ) if response is None: raise RuntimeError('Got None instead of a bot response.') await ws.send_json(self.output_formatter(response['dialog'].to_dict())) else: await ws.close() break return ws async def options(self, request): return web.Response(headers={'Access-Control-Allow-Methods': 'GET, OPTIONS'})

true

f713385808bf177da45209fad36598a397b9c0a6

1,161

py

Python

ixian_docker/modules/python/__init__.py

kreneskyp/ixian-docker

ce7a6cee2f961b8446dc3d9429a809ab5a235467

[ "Apache-2.0" ]

null

ixian_docker/modules/python/__init__.py

kreneskyp/ixian-docker

ce7a6cee2f961b8446dc3d9429a809ab5a235467

[ "Apache-2.0" ]

null

ixian_docker/modules/python/__init__.py

kreneskyp/ixian-docker

ce7a6cee2f961b8446dc3d9429a809ab5a235467

[ "Apache-2.0" ]

null

# Copyright [2018-2020] Peter Krenesky # # 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. OPTIONS = { "name": "PYTHON", "tasks": "ixian_docker.modules.python.tasks", "config": "ixian_docker.modules.python.config.PythonConfig", "dockerfile_template": "{PYTHON.MODULE_DIR}/Dockerfile.template", # Dev volumes mounted only in local environment "dev_volumes": [ # Pipenv "{PYTHON.VIRTUAL_ENV_VOLUME}:{PYTHON.VIRTUAL_ENV_DIR}", # Mount Pipfile in because it can't be symlinked. "{PWD}/Pipfile:{DOCKER.APP_DIR}/Pipfile", # ipython history "{BUILDER}/.ipython/:{DOCKER.HOME_DIR}/.ipython/", ], }

38.7

74

0.704565

OPTIONS = { "name": "PYTHON", "tasks": "ixian_docker.modules.python.tasks", "config": "ixian_docker.modules.python.config.PythonConfig", "dockerfile_template": "{PYTHON.MODULE_DIR}/Dockerfile.template", "dev_volumes": [ "{PYTHON.VIRTUAL_ENV_VOLUME}:{PYTHON.VIRTUAL_ENV_DIR}", "{PWD}/Pipfile:{DOCKER.APP_DIR}/Pipfile", # ipython history "{BUILDER}/.ipython/:{DOCKER.HOME_DIR}/.ipython/", ], }

true

f7133991f9d64a1c26537f8731343872af210587

4,373

py

Python

vision/google/cloud/vision_v1p1beta1/gapic/transports/image_annotator_grpc_transport.py

DaveCheez/google-cloud-python

fc03d4d41f13e9d13db7206438163b3a471fdabd

[ "Apache-2.0" ]

null

vision/google/cloud/vision_v1p1beta1/gapic/transports/image_annotator_grpc_transport.py

DaveCheez/google-cloud-python

fc03d4d41f13e9d13db7206438163b3a471fdabd

[ "Apache-2.0" ]

null

vision/google/cloud/vision_v1p1beta1/gapic/transports/image_annotator_grpc_transport.py

DaveCheez/google-cloud-python

fc03d4d41f13e9d13db7206438163b3a471fdabd

[ "Apache-2.0" ]

1

2021-07-21T17:59:33.000Z

# -*- coding: utf-8 -*- # # Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import google.api_core.grpc_helpers from google.cloud.vision_v1p1beta1.proto import image_annotator_pb2_grpc class ImageAnnotatorGrpcTransport(object): """gRPC transport class providing stubs for google.cloud.vision.v1p1beta1 ImageAnnotator API. The transport provides access to the raw gRPC stubs, which can be used to take advantage of advanced features of gRPC. """ # The scopes needed to make gRPC calls to all of the methods defined # in this service. _OAUTH_SCOPES = ( "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-vision", ) def __init__( self, channel=None, credentials=None, address="vision.googleapis.com:443" ): """Instantiate the transport class. Args: channel (grpc.Channel): A ``Channel`` instance through which to make calls. This argument is mutually exclusive with ``credentials``; providing both will raise an exception. credentials (google.auth.credentials.Credentials): The authorization credentials to attach to requests. These credentials identify this application to the service. If none are specified, the client will attempt to ascertain the credentials from the environment. address (str): The address where the service is hosted. """ # If both `channel` and `credentials` are specified, raise an # exception (channels come with credentials baked in already). if channel is not None and credentials is not None: raise ValueError( "The `channel` and `credentials` arguments are mutually " "exclusive." ) # Create the channel. if channel is None: channel = self.create_channel(address=address, credentials=credentials) self._channel = channel # gRPC uses objects called "stubs" that are bound to the # channel and provide a basic method for each RPC. self._stubs = { "image_annotator_stub": image_annotator_pb2_grpc.ImageAnnotatorStub(channel) } @classmethod def create_channel( cls, address="vision.googleapis.com:443", credentials=None, **kwargs ): """Create and return a gRPC channel object. Args: address (str): The host for the channel to use. credentials (~.Credentials): The authorization credentials to attach to requests. These credentials identify this application to the service. If none are specified, the client will attempt to ascertain the credentials from the environment. kwargs (dict): Keyword arguments, which are passed to the channel creation. Returns: grpc.Channel: A gRPC channel object. """ return google.api_core.grpc_helpers.create_channel( address, credentials=credentials, scopes=cls._OAUTH_SCOPES, **kwargs ) @property def channel(self): """The gRPC channel used by the transport. Returns: grpc.Channel: A gRPC channel object. """ return self._channel @property def batch_annotate_images(self): """Return the gRPC stub for :meth:`ImageAnnotatorClient.batch_annotate_images`. Run image detection and annotation for a batch of images. Returns: Callable: A callable which accepts the appropriate deserialized request object and returns a deserialized response object. """ return self._stubs["image_annotator_stub"].BatchAnnotateImages

37.059322

88

0.655157

import google.api_core.grpc_helpers from google.cloud.vision_v1p1beta1.proto import image_annotator_pb2_grpc class ImageAnnotatorGrpcTransport(object): _OAUTH_SCOPES = ( "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-vision", ) def __init__( self, channel=None, credentials=None, address="vision.googleapis.com:443" ): if channel is not None and credentials is not None: raise ValueError( "The `channel` and `credentials` arguments are mutually " "exclusive." ) if channel is None: channel = self.create_channel(address=address, credentials=credentials) self._channel = channel self._stubs = { "image_annotator_stub": image_annotator_pb2_grpc.ImageAnnotatorStub(channel) } @classmethod def create_channel( cls, address="vision.googleapis.com:443", credentials=None, **kwargs ): return google.api_core.grpc_helpers.create_channel( address, credentials=credentials, scopes=cls._OAUTH_SCOPES, **kwargs ) @property def channel(self): return self._channel @property def batch_annotate_images(self): return self._stubs["image_annotator_stub"].BatchAnnotateImages

true

f7133a11baac4ba39d89801689a8b42a671c52b0

19,617

py

Python

aiida_yambo/calculations/yambo.py

qiaojunfeng/yambo-aiida

1900f2a0932b7782759740e5835620dbfb897a76

[ "MIT", "BSD-3-Clause" ]

3

2018-10-30T14:00:40.000Z

2020-04-11T08:03:10.000Z

aiida_yambo/calculations/yambo.py

qiaojunfeng/yambo-aiida

1900f2a0932b7782759740e5835620dbfb897a76

[ "MIT", "BSD-3-Clause" ]

32

2017-10-23T17:11:35.000Z

2022-03-28T10:04:23.000Z

aiida_yambo/calculations/yambo.py

qiaojunfeng/yambo-aiida

1900f2a0932b7782759740e5835620dbfb897a76

[ "MIT", "BSD-3-Clause" ]

6

2017-10-23T17:01:13.000Z

2022-03-15T18:20:35.000Z

# -*- coding: utf-8 -*- """ Plugin to create a Yambo input file and run a calculation with the yambo executable. """ from __future__ import absolute_import import os import six from aiida.engine import CalcJob from aiida_quantumespresso.calculations import _lowercase_dict, _uppercase_dict from aiida.common.datastructures import CalcInfo from aiida.common.datastructures import CalcJobState from aiida.common.exceptions import UniquenessError, InputValidationError, ValidationError from aiida.common.utils import classproperty from aiida.orm import Code from aiida.orm.nodes import Dict from aiida.orm.nodes import RemoteData, BandsData, ArrayData from aiida.plugins import DataFactory, CalculationFactory from aiida.common import AIIDA_LOGGER from aiida.common import LinkType from aiida_yambo.utils.common_helpers import * PwCalculation = CalculationFactory('quantumespresso.pw') __authors__ = " Miki Bonacci (miki.bonacci@unimore.it)," \ " Gianluca Prandini (gianluca.prandini@epfl.ch)," \ " Antimo Marrazzo (antimo.marrazzo@epfl.ch)," \ " Michael Atambo (michaelontita.atambo@unimore.it)." class YamboCalculation(CalcJob): """ AiiDA plugin for the Yambo code. For more information, refer to http://www.yambo-code.org/ https://github.com/yambo-code/yambo-aiida and http://aiida-yambo.readthedocs.io/en/latest/ """ # Default input and output files _DEFAULT_INPUT_FILE = 'aiida.in' _DEFAULT_OUTPUT_FILE = 'aiida.out' @classmethod def define(cls,spec): super(YamboCalculation, cls).define(spec) spec.input('metadata.options.input_filename', valid_type=six.string_types, default=cls._DEFAULT_INPUT_FILE) spec.input('metadata.options.output_filename', valid_type=six.string_types, default=cls._DEFAULT_OUTPUT_FILE) # Default output parser provided by AiiDA spec.input('metadata.options.parser_name', valid_type=six.string_types, default='yambo.yambo') # self._SCRATCH_FOLDER = 'SAVE' spec.input('metadata.options.scratch_folder', valid_type=six.string_types, default='SAVE') spec.input('metadata.options.logostring', valid_type=six.string_types, default=""" # # Y88b / e e e 888~~\ ,88~-_ # Y88b / d8b d8b d8b 888 | d888 \ # Y88b/ /Y88b d888bdY88b 888 _/ 88888 | # Y8Y / Y88b / Y88Y Y888b 888 \ 88888 | # Y /____Y88b / YY Y888b 888 | Y888 / # / / Y88b / Y888b 888__/ `88_-~ # # AIIDA input plugin. YAMBO 4.x compatible # http://www.yambo-code.org # """ ) spec.input('settings',valid_type=Dict, help='Use an additional node for special settings') spec.input('parameters',valid_type=Dict, help='Use a node that specifies the input parameters') spec.input('parent_folder',valid_type=RemoteData, help='Use a remote folder as parent folder (for "restarts and similar"') spec.input('preprocessing_code',valid_type=Code, help='Use a preprocessing code for starting yambo',required=False) spec.input('precode_parameters',valid_type=Dict, help='Use a node that specifies the input parameters for the yambo precode',required=False) spec.input('code',valid_type=Code, help='Use a main code for yambo calculation') spec.exit_code(500, 'ERROR_NO_RETRIEVED_FOLDER', message='The retrieved folder data node could not be accessed.') spec.exit_code(501, 'WALLTIME_ERROR', message='time exceeded the max walltime') spec.exit_code(502, 'NO_SUCCESS', message='failed calculation for some reason: could be a low number of conduction bands') spec.exit_code(503, 'PARSER_ANOMALY', message='Unexpected behavior of YamboFolder') spec.exit_code(504, 'PARA_ERROR', message='parallelization error') spec.exit_code(505, 'MEMORY_ERROR', message='general memory error') spec.exit_code(506, 'X_par_MEMORY_ERROR', message='x_par allocation memory error') #outputs definition: spec.output('output_parameters', valid_type=Dict, required=True, help='returns the output parameters') spec.output('array_alpha', valid_type=ArrayData, required=False, help='returns the alpha array') spec.output('array_alpha_bands', valid_type=ArrayData, required=False, help='returns the alpha array bands') spec.output('array_alpha_array', valid_type=ArrayData, required=False, help='returns the alpha array') spec.output('bands_quasiparticle', valid_type=BandsData, required=False, help='returns the quasiparticle band structure') spec.output('array_qp', valid_type=ArrayData, required=False, help='returns the quasiparticle array band structure') spec.output('array_eels', valid_type=ArrayData, required=False, help='returns the eels array') spec.output('array_eps', valid_type=ArrayData, required=False, help='returns the eps array') spec.output('array_ndb', valid_type=ArrayData, required=False, help='returns the array for ndb') spec.output('array_ndb_QP', valid_type=ArrayData, required=False, help='returns the array for ndbQP') spec.output('array_ndb_HFlocXC', valid_type=ArrayData, required=False, help='returns the array ndb for HFlocXC') spec.output('system_info', valid_type=Dict, required=False, help='returns some system information after a p2y') def prepare_for_submission(self, tempfolder): _dbs_accepted = {'gw0': 'ndb.QP', 'HF_and_locXC': 'ndb.HF_and_locXC',} local_copy_list = [] remote_copy_list = [] remote_symlink_list = [] # Settings can be undefined, and defaults to an empty dictionary. # They will be used for any input that doen't fit elsewhere. settings = self.inputs.settings.get_dict() initialise = settings.pop('INITIALISE', None) if initialise is not None: if not isinstance(initialise, bool): raise InputValidationError("INITIALISE must be " " a boolean") copy_save = settings.pop('COPY_SAVE', None) if copy_save is not None: if not isinstance(copy_save, bool): raise InputValidationError("COPY_SAVE must be " " a boolean") copy_dbs = settings.pop('COPY_DBS', None) if copy_dbs is not None: if not isinstance(copy_dbs, bool): raise InputValidationError("COPY_DBS must be " " a boolean") restart_yambo = settings.pop('RESTART_YAMBO', None) if restart_yambo is not None: if not isinstance(restart_yambo, bool): raise InputValidationError("RESTART_YAMBO must be " " a boolean") parameters = self.inputs.parameters if not initialise: if not isinstance(parameters, Dict): raise InputValidationError("parameters is not of type Dict") parent_calc_folder = self.inputs.parent_folder main_code = self.inputs.code preproc_code = self.inputs.preprocessing_code parent_calc = take_calc_from_remote(parent_calc_folder) if parent_calc.process_type=='aiida.calculations:yambo.yambo': yambo_parent=True else: yambo_parent=False # flags for yambo interfaces try: precode_param_dict = self.inputs.precode_parameters except: precode_param_dict = Dict(dict={}) # check the precode parameters given in input input_cmdline = settings.pop('CMDLINE', None) import re precode_params_list = [] #['cd aiida.save'] ##.format(parent_calc_folder._PREFIX) pattern = re.compile(r"(^\-)([a-zA-Z])") for key, value in six.iteritems(precode_param_dict.get_dict()): if re.search(pattern, key) is not None: if key == '-O' or key == '-H' or key == '-h' or key == '-F': raise InputValidationError( "Precode flag {} is not allowed".format(str(key))) else: if precode_param_dict[key] is True: precode_params_list.append(str(key)) elif precode_param_dict[key] is False: pass else: precode_params_list.append('{}'.format(str(key))) precode_params_list.append('{}'.format(str(value))) else: raise InputValidationError( "Wrong format of precode_parameters") # Adding manual cmdline input (e.g. for DB fragmentation) if input_cmdline is not None: precode_params_list = precode_params_list + input_cmdline # TODO: check that remote data must be on the same computer ############################## # END OF INITIAL INPUT CHECK # ############################## if not initialise: ################################################### # Prepare yambo input file ################################################### params_dict = parameters.get_dict() # extract boolean keys boolean_dict = { k: v for k, v in six.iteritems(params_dict) if isinstance(v, bool) } params_dict = { k: v for k, v in six.iteritems(params_dict) if k not in list(boolean_dict.keys()) } # reorganize the dictionary and create a list of dictionaries with key, value and units parameters_list = [] for k, v in six.iteritems(params_dict): if "_units" in k: continue units_key = "{}_units".format(k) try: units = params_dict[units_key] except KeyError: units = None this_dict = {} this_dict['key'] = k this_dict['value'] = v this_dict['units'] = units parameters_list.append(this_dict) input_filename = tempfolder.get_abs_path(self.metadata.options.input_filename) with open(input_filename, 'w') as infile: infile.write(self.metadata.options.logostring) for k, v in six.iteritems(boolean_dict): if v: infile.write("{}\n".format(k)) for this_dict in parameters_list: key = this_dict['key'] value = this_dict['value'] units = this_dict['units'] if isinstance(value, list): value_string = '' try: for v in value: value_string += " | ".join([str(_) for _ in v]) + " |\n" except: value_string += " | ".join([str(_) for _ in value]) + " |\n" the_string = "% {}\n {}".format(key, value_string) the_string += "%" else: the_value = '"{}"'.format(value) if isinstance( value, six.string_types) else '{}'.format(value) the_string = "{} = {}".format(key, the_value) if units is not None: the_string += " {}".format(units) infile.write(the_string + "\n") ############################################ # set copy of the parent calculation ############################################ try: parent_calc = parent_calc_folder.get_incoming().all_nodes()[-1] #to load the node from a workchain... except: parent_calc = parent_calc_folder.get_incoming().get_node_by_label('remote_folder') if yambo_parent: if copy_save: try: remote_copy_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/SAVE/",'./SAVE/')) except: remote_copy_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"out/aiida.save/SAVE/",'./SAVE/')) else: try: remote_symlink_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/SAVE/",'./SAVE/')) except: remote_symlink_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"out/aiida.save/SAVE/",'./SAVE/')) if copy_dbs: remote_copy_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/aiida.out/",'./aiida.out/')) if restart_yambo: remote_symlink_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/aiida.out/",'./aiida.out/')) else: remote_copy_list.append( (parent_calc_folder.computer.uuid, os.path.join(parent_calc_folder.get_remote_path(), PwCalculation._OUTPUT_SUBFOLDER, "aiida.save","*" ), ##.format(parent_calc_folder._PREFIX) "." ) ) ############################################ # set Calcinfo ############################################ calcinfo = CalcInfo() calcinfo.uuid = self.uuid calcinfo.local_copy_list = [] calcinfo.remote_copy_list = remote_copy_list calcinfo.remote_symlink_list = remote_symlink_list # Retrieve by default the output file and the xml file calcinfo.retrieve_list = [] calcinfo.retrieve_list.append('r*') calcinfo.retrieve_list.append('l*') calcinfo.retrieve_list.append('o*') calcinfo.retrieve_list.append('LOG/l*_CPU_1') calcinfo.retrieve_list.append('LOG/l*_CPU_2') calcinfo.retrieve_list.append('*stderr*') #standard errors extra_retrieved = [] if initialise: # extra_retrieved.append('SAVE/'+_dbs_accepted['ns.db1']) pass else: for dbs in _dbs_accepted.keys(): db = boolean_dict.pop(dbs,False) if db: extra_retrieved.append('aiida.out/'+_dbs_accepted[dbs]) additional = settings.pop('ADDITIONAL_RETRIEVE_LIST',[]) if additional: extra_retrieved.append(additional) for extra in extra_retrieved: calcinfo.retrieve_list.append(extra) from aiida.common.datastructures import CodeRunMode, CodeInfo # c1 = interface dft codes and yambo (ex. p2y or a2y) c1 = CodeInfo() c1.withmpi = True c1.cmdline_params = precode_params_list # c2 = yambo initialization c2 = CodeInfo() c2.withmpi = True c2.cmdline_params = [] c2.code_uuid = main_code.uuid # if the parent calculation is a yambo calculation skip the interface (c1) and the initialization (c2) if yambo_parent: try: parent_settings = _uppercase_dict( parent_calc.inputs.settings.get_dict(), dict_name='parent settings') parent_initialise = parent_settings['INITIALISE'] except KeyError: parent_initialise = False c1 = None if not parent_initialise: c2 = None else: c1.cmdline_params = precode_params_list c1.code_uuid = preproc_code.uuid # c3 = yambo calculation c3 = CodeInfo() c3.withmpi = True #c3.withmpi = self.get_withmpi() c3.cmdline_params = [ "-F", self.metadata.options.input_filename, \ '-J', self.metadata.options.output_filename, \ ] c3.code_uuid = main_code.uuid if initialise: c2 = None c3 = None #logic of the execution #calcinfo.codes_info = [c1, c2, c3] if not yambo_parent else [c3] if yambo_parent: if not parent_initialise: calcinfo.codes_info = [c3] else: calcinfo.codes_info = [c2, c3] elif initialise: calcinfo.codes_info = [c1] else: calcinfo.codes_info = [c1, c2, c3] calcinfo.codes_run_mode = CodeRunMode.SERIAL if settings: raise InputValidationError( "The following keys have been found in " "the settings input node, but were not understood: {}".format( ",".join(list(settings.keys())))) return calcinfo ################################################################################ #the following functions are not used def _check_valid_parent(self, calc): """ Check that calc is a valid parent for a YamboCalculation. It can be a PwCalculation or a YamboCalculation. """ try: if ((not isinstance(calc, PwCalculation)) and (not isinstance(calc, YamboCalculation))): raise ValueError( "Parent calculation must be a PwCalculation or a YamboCalculation" ) except ImportError: if ((not isinstance(calc, PwCalculation)) and (not isinstance(calc, YamboCalculation))): raise ValueError( "Parent calculation must be a PwCalculation or a YamboCalculation" ) def use_parent_calculation(self, calc): """ Set the parent calculation of Yambo, from which it will inherit the outputsubfolder. The link will be created from parent RemoteData to YamboCalculation """ from aiida.common.exceptions import NotExistent self._check_valid_parent(calc) remotedatas = calc.get_outputs(node_type=RemoteData) if not remotedatas: raise NotExistent("No output remotedata found in " "the parent") if len(remotedatas) != 1: raise UniquenessError("More than one output remotedata found in " "the parent") remotedata = remotedatas[0] self._set_parent_remotedata(remotedata) def _set_parent_remotedata(self, remotedata): """ Used to set a parent remotefolder in the start of Yambo. """ if not isinstance(remotedata, RemoteData): raise ValueError('remotedata must be a RemoteData') # complain if another remotedata is already found input_remote = self.get_inputs(node_type=RemoteData) if input_remote: raise ValidationError("Cannot set several parent calculation to a " "Yambo calculation") self.use_parent_folder(remotedata)

39.953157

152

0.5744

from __future__ import absolute_import import os import six from aiida.engine import CalcJob from aiida_quantumespresso.calculations import _lowercase_dict, _uppercase_dict from aiida.common.datastructures import CalcInfo from aiida.common.datastructures import CalcJobState from aiida.common.exceptions import UniquenessError, InputValidationError, ValidationError from aiida.common.utils import classproperty from aiida.orm import Code from aiida.orm.nodes import Dict from aiida.orm.nodes import RemoteData, BandsData, ArrayData from aiida.plugins import DataFactory, CalculationFactory from aiida.common import AIIDA_LOGGER from aiida.common import LinkType from aiida_yambo.utils.common_helpers import * PwCalculation = CalculationFactory('quantumespresso.pw') __authors__ = " Miki Bonacci (miki.bonacci@unimore.it)," \ " Gianluca Prandini (gianluca.prandini@epfl.ch)," \ " Antimo Marrazzo (antimo.marrazzo@epfl.ch)," \ " Michael Atambo (michaelontita.atambo@unimore.it)." class YamboCalculation(CalcJob): _DEFAULT_INPUT_FILE = 'aiida.in' _DEFAULT_OUTPUT_FILE = 'aiida.out' @classmethod def define(cls,spec): super(YamboCalculation, cls).define(spec) spec.input('metadata.options.input_filename', valid_type=six.string_types, default=cls._DEFAULT_INPUT_FILE) spec.input('metadata.options.output_filename', valid_type=six.string_types, default=cls._DEFAULT_OUTPUT_FILE) spec.input('metadata.options.parser_name', valid_type=six.string_types, default='yambo.yambo') spec.input('metadata.options.scratch_folder', valid_type=six.string_types, default='SAVE') spec.input('metadata.options.logostring', valid_type=six.string_types, default=""" # # Y88b / e e e 888~~\ ,88~-_ # Y88b / d8b d8b d8b 888 | d888 \ # Y88b/ /Y88b d888bdY88b 888 _/ 88888 | # Y8Y / Y88b / Y88Y Y888b 888 \ 88888 | # Y /____Y88b / YY Y888b 888 | Y888 / # / / Y88b / Y888b 888__/ `88_-~ # # AIIDA input plugin. YAMBO 4.x compatible # http://www.yambo-code.org # """ ) spec.input('settings',valid_type=Dict, help='Use an additional node for special settings') spec.input('parameters',valid_type=Dict, help='Use a node that specifies the input parameters') spec.input('parent_folder',valid_type=RemoteData, help='Use a remote folder as parent folder (for "restarts and similar"') spec.input('preprocessing_code',valid_type=Code, help='Use a preprocessing code for starting yambo',required=False) spec.input('precode_parameters',valid_type=Dict, help='Use a node that specifies the input parameters for the yambo precode',required=False) spec.input('code',valid_type=Code, help='Use a main code for yambo calculation') spec.exit_code(500, 'ERROR_NO_RETRIEVED_FOLDER', message='The retrieved folder data node could not be accessed.') spec.exit_code(501, 'WALLTIME_ERROR', message='time exceeded the max walltime') spec.exit_code(502, 'NO_SUCCESS', message='failed calculation for some reason: could be a low number of conduction bands') spec.exit_code(503, 'PARSER_ANOMALY', message='Unexpected behavior of YamboFolder') spec.exit_code(504, 'PARA_ERROR', message='parallelization error') spec.exit_code(505, 'MEMORY_ERROR', message='general memory error') spec.exit_code(506, 'X_par_MEMORY_ERROR', message='x_par allocation memory error') spec.output('output_parameters', valid_type=Dict, required=True, help='returns the output parameters') spec.output('array_alpha', valid_type=ArrayData, required=False, help='returns the alpha array') spec.output('array_alpha_bands', valid_type=ArrayData, required=False, help='returns the alpha array bands') spec.output('array_alpha_array', valid_type=ArrayData, required=False, help='returns the alpha array') spec.output('bands_quasiparticle', valid_type=BandsData, required=False, help='returns the quasiparticle band structure') spec.output('array_qp', valid_type=ArrayData, required=False, help='returns the quasiparticle array band structure') spec.output('array_eels', valid_type=ArrayData, required=False, help='returns the eels array') spec.output('array_eps', valid_type=ArrayData, required=False, help='returns the eps array') spec.output('array_ndb', valid_type=ArrayData, required=False, help='returns the array for ndb') spec.output('array_ndb_QP', valid_type=ArrayData, required=False, help='returns the array for ndbQP') spec.output('array_ndb_HFlocXC', valid_type=ArrayData, required=False, help='returns the array ndb for HFlocXC') spec.output('system_info', valid_type=Dict, required=False, help='returns some system information after a p2y') def prepare_for_submission(self, tempfolder): _dbs_accepted = {'gw0': 'ndb.QP', 'HF_and_locXC': 'ndb.HF_and_locXC',} local_copy_list = [] remote_copy_list = [] remote_symlink_list = [] settings = self.inputs.settings.get_dict() initialise = settings.pop('INITIALISE', None) if initialise is not None: if not isinstance(initialise, bool): raise InputValidationError("INITIALISE must be " " a boolean") copy_save = settings.pop('COPY_SAVE', None) if copy_save is not None: if not isinstance(copy_save, bool): raise InputValidationError("COPY_SAVE must be " " a boolean") copy_dbs = settings.pop('COPY_DBS', None) if copy_dbs is not None: if not isinstance(copy_dbs, bool): raise InputValidationError("COPY_DBS must be " " a boolean") restart_yambo = settings.pop('RESTART_YAMBO', None) if restart_yambo is not None: if not isinstance(restart_yambo, bool): raise InputValidationError("RESTART_YAMBO must be " " a boolean") parameters = self.inputs.parameters if not initialise: if not isinstance(parameters, Dict): raise InputValidationError("parameters is not of type Dict") parent_calc_folder = self.inputs.parent_folder main_code = self.inputs.code preproc_code = self.inputs.preprocessing_code parent_calc = take_calc_from_remote(parent_calc_folder) if parent_calc.process_type=='aiida.calculations:yambo.yambo': yambo_parent=True else: yambo_parent=False # flags for yambo interfaces try: precode_param_dict = self.inputs.precode_parameters except: precode_param_dict = Dict(dict={}) # check the precode parameters given in input input_cmdline = settings.pop('CMDLINE', None) import re precode_params_list = [] #['cd aiida.save'] ##.format(parent_calc_folder._PREFIX) pattern = re.compile(r"(^\-)([a-zA-Z])") for key, value in six.iteritems(precode_param_dict.get_dict()): if re.search(pattern, key) is not None: if key == '-O' or key == '-H' or key == '-h' or key == '-F': raise InputValidationError( "Precode flag {} is not allowed".format(str(key))) else: if precode_param_dict[key] is True: precode_params_list.append(str(key)) elif precode_param_dict[key] is False: pass else: precode_params_list.append('{}'.format(str(key))) precode_params_list.append('{}'.format(str(value))) else: raise InputValidationError( "Wrong format of precode_parameters") # Adding manual cmdline input (e.g. for DB fragmentation) if input_cmdline is not None: precode_params_list = precode_params_list + input_cmdline # TODO: check that remote data must be on the same computer ############################## # END OF INITIAL INPUT CHECK # ############################## if not initialise: ################################################### # Prepare yambo input file ################################################### params_dict = parameters.get_dict() # extract boolean keys boolean_dict = { k: v for k, v in six.iteritems(params_dict) if isinstance(v, bool) } params_dict = { k: v for k, v in six.iteritems(params_dict) if k not in list(boolean_dict.keys()) } # reorganize the dictionary and create a list of dictionaries with key, value and units parameters_list = [] for k, v in six.iteritems(params_dict): if "_units" in k: continue units_key = "{}_units".format(k) try: units = params_dict[units_key] except KeyError: units = None this_dict = {} this_dict['key'] = k this_dict['value'] = v this_dict['units'] = units parameters_list.append(this_dict) input_filename = tempfolder.get_abs_path(self.metadata.options.input_filename) with open(input_filename, 'w') as infile: infile.write(self.metadata.options.logostring) for k, v in six.iteritems(boolean_dict): if v: infile.write("{}\n".format(k)) for this_dict in parameters_list: key = this_dict['key'] value = this_dict['value'] units = this_dict['units'] if isinstance(value, list): value_string = '' try: for v in value: value_string += " | ".join([str(_) for _ in v]) + " |\n" except: value_string += " | ".join([str(_) for _ in value]) + " |\n" the_string = "% {}\n {}".format(key, value_string) the_string += "%" else: the_value = '"{}"'.format(value) if isinstance( value, six.string_types) else '{}'.format(value) the_string = "{} = {}".format(key, the_value) if units is not None: the_string += " {}".format(units) infile.write(the_string + "\n") ############################################ # set copy of the parent calculation ############################################ try: parent_calc = parent_calc_folder.get_incoming().all_nodes()[-1] #to load the node from a workchain... except: parent_calc = parent_calc_folder.get_incoming().get_node_by_label('remote_folder') if yambo_parent: if copy_save: try: remote_copy_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/SAVE/",'./SAVE/')) except: remote_copy_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"out/aiida.save/SAVE/",'./SAVE/')) else: try: remote_symlink_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/SAVE/",'./SAVE/')) except: remote_symlink_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"out/aiida.save/SAVE/",'./SAVE/')) if copy_dbs: remote_copy_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/aiida.out/",'./aiida.out/')) if restart_yambo: remote_symlink_list.append((parent_calc_folder.computer.uuid,parent_calc_folder.get_remote_path()+"/aiida.out/",'./aiida.out/')) else: remote_copy_list.append( (parent_calc_folder.computer.uuid, os.path.join(parent_calc_folder.get_remote_path(), PwCalculation._OUTPUT_SUBFOLDER, "aiida.save","*" ), ##.format(parent_calc_folder._PREFIX) "." ) ) ############################################ # set Calcinfo ############################################ calcinfo = CalcInfo() calcinfo.uuid = self.uuid calcinfo.local_copy_list = [] calcinfo.remote_copy_list = remote_copy_list calcinfo.remote_symlink_list = remote_symlink_list # Retrieve by default the output file and the xml file calcinfo.retrieve_list = [] calcinfo.retrieve_list.append('r*') calcinfo.retrieve_list.append('l*') calcinfo.retrieve_list.append('o*') calcinfo.retrieve_list.append('LOG/l*_CPU_1') calcinfo.retrieve_list.append('LOG/l*_CPU_2') calcinfo.retrieve_list.append('*stderr*') #standard errors extra_retrieved = [] if initialise: # extra_retrieved.append('SAVE/'+_dbs_accepted['ns.db1']) pass else: for dbs in _dbs_accepted.keys(): db = boolean_dict.pop(dbs,False) if db: extra_retrieved.append('aiida.out/'+_dbs_accepted[dbs]) additional = settings.pop('ADDITIONAL_RETRIEVE_LIST',[]) if additional: extra_retrieved.append(additional) for extra in extra_retrieved: calcinfo.retrieve_list.append(extra) from aiida.common.datastructures import CodeRunMode, CodeInfo # c1 = interface dft codes and yambo (ex. p2y or a2y) c1 = CodeInfo() c1.withmpi = True c1.cmdline_params = precode_params_list # c2 = yambo initialization c2 = CodeInfo() c2.withmpi = True c2.cmdline_params = [] c2.code_uuid = main_code.uuid # if the parent calculation is a yambo calculation skip the interface (c1) and the initialization (c2) if yambo_parent: try: parent_settings = _uppercase_dict( parent_calc.inputs.settings.get_dict(), dict_name='parent settings') parent_initialise = parent_settings['INITIALISE'] except KeyError: parent_initialise = False c1 = None if not parent_initialise: c2 = None else: c1.cmdline_params = precode_params_list c1.code_uuid = preproc_code.uuid # c3 = yambo calculation c3 = CodeInfo() c3.withmpi = True #c3.withmpi = self.get_withmpi() c3.cmdline_params = [ "-F", self.metadata.options.input_filename, \ '-J', self.metadata.options.output_filename, \ ] c3.code_uuid = main_code.uuid if initialise: c2 = None c3 = None #logic of the execution #calcinfo.codes_info = [c1, c2, c3] if not yambo_parent else [c3] if yambo_parent: if not parent_initialise: calcinfo.codes_info = [c3] else: calcinfo.codes_info = [c2, c3] elif initialise: calcinfo.codes_info = [c1] else: calcinfo.codes_info = [c1, c2, c3] calcinfo.codes_run_mode = CodeRunMode.SERIAL if settings: raise InputValidationError( "The following keys have been found in " "the settings input node, but were not understood: {}".format( ",".join(list(settings.keys())))) return calcinfo ################################################################################ #the following functions are not used def _check_valid_parent(self, calc): try: if ((not isinstance(calc, PwCalculation)) and (not isinstance(calc, YamboCalculation))): raise ValueError( "Parent calculation must be a PwCalculation or a YamboCalculation" ) except ImportError: if ((not isinstance(calc, PwCalculation)) and (not isinstance(calc, YamboCalculation))): raise ValueError( "Parent calculation must be a PwCalculation or a YamboCalculation" ) def use_parent_calculation(self, calc): from aiida.common.exceptions import NotExistent self._check_valid_parent(calc) remotedatas = calc.get_outputs(node_type=RemoteData) if not remotedatas: raise NotExistent("No output remotedata found in " "the parent") if len(remotedatas) != 1: raise UniquenessError("More than one output remotedata found in " "the parent") remotedata = remotedatas[0] self._set_parent_remotedata(remotedata) def _set_parent_remotedata(self, remotedata): if not isinstance(remotedata, RemoteData): raise ValueError('remotedata must be a RemoteData') # complain if another remotedata is already found input_remote = self.get_inputs(node_type=RemoteData) if input_remote: raise ValidationError("Cannot set several parent calculation to a " "Yambo calculation") self.use_parent_folder(remotedata)

true

f7133c4cef8d53f6b9706fa1a69dcc17bde30732

1,116

py

Python

users/migrations/0001_initial.py

Audio10/Django

c2cb09b95014b1213a073c055d3f0ef793ecf5bf

[ "MIT" ]

null

users/migrations/0001_initial.py

Audio10/Django

c2cb09b95014b1213a073c055d3f0ef793ecf5bf

[ "MIT" ]

null

users/migrations/0001_initial.py

Audio10/Django

c2cb09b95014b1213a073c055d3f0ef793ecf5bf

[ "MIT" ]

null

# Generated by Django 3.0.3 on 2020-03-02 14:44 from django.conf import settings from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): initial = True dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name='Profile', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('website', models.URLField(blank=True)), ('biography', models.TextField(blank=True)), ('phone_number', models.CharField(blank=True, max_length=20)), ('picture', models.ImageField(blank=True, null=True, upload_to='users/pictures')), ('created', models.DateTimeField(auto_now_add=True)), ('modified', models.DateTimeField(auto_now=True)), ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)), ], ), ]

36

121

0.624552

from django.conf import settings from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): initial = True dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name='Profile', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('website', models.URLField(blank=True)), ('biography', models.TextField(blank=True)), ('phone_number', models.CharField(blank=True, max_length=20)), ('picture', models.ImageField(blank=True, null=True, upload_to='users/pictures')), ('created', models.DateTimeField(auto_now_add=True)), ('modified', models.DateTimeField(auto_now=True)), ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)), ], ), ]

true

f7133c6d368df3e67e9493eaa4b25a9af6670a77

2,195

py

Python

tests/unit/media/test_listener.py

AnantTiwari-Naman/pyglet

4774f2889057da95a78785a69372112931e6a620

[ "BSD-3-Clause" ]

1,160

2019-06-13T11:51:40.000Z

2022-03-31T01:55:32.000Z

tests/unit/media/test_listener.py

AaronCWacker/pyglet

63b1ece7043133d47eb898857876e4927d9759b2

[ "BSD-3-Clause" ]

491

2019-07-14T16:13:11.000Z

2022-03-31T08:04:32.000Z

tests/unit/media/test_listener.py

AaronCWacker/pyglet

63b1ece7043133d47eb898857876e4927d9759b2

[ "BSD-3-Clause" ]

316

2019-06-14T13:56:48.000Z

2022-03-30T19:26:58.000Z

import pytest from ...annotations import skip_if_continuous_integration try: from pyglet.media.drivers import pulse has_pulse = True except ImportError: has_pulse = False try: from pyglet.media.drivers import openal has_openal = True except ImportError: has_openal = False try: from pyglet.media.drivers import directsound has_directsound = True except ImportError: has_directsound = False def check_listener_defaults(listener): assert listener.volume == 1.0 assert listener.position == (0, 0, 0) assert listener.forward_orientation == (0, 0, -1) assert listener.up_orientation == (0, 1, 0) def check_modifying_values(listener): listener.volume = 0.5 listener.position = (-1, 0, 0) listener.forward_orientation = (0, 0, 1) listener.up_orientation = (0, -1, 0) assert listener.volume == 0.5 assert listener.position == (-1, 0, 0) assert listener.forward_orientation == (0, 0, 1) assert listener.up_orientation == (0, -1, 0) @pytest.mark.skipif(not has_openal, reason="Test requires OpenAL") def test_openal_listener(): driver = openal.create_audio_driver() listener = driver.get_listener() check_listener_defaults(listener=listener) check_modifying_values(listener=listener) # Need to garbage collect the listener before the driver is deleted del listener @skip_if_continuous_integration() # test user cannot connect to PulseAudio daemon @pytest.mark.skipif(not has_pulse, reason="Test requires PulseAudio") def test_pulse_listener(): driver = pulse.create_audio_driver() listener = driver.get_listener() check_listener_defaults(listener=listener) check_modifying_values(listener=listener) # Need to garbage collect the listener before the driver is deleted del listener @pytest.mark.skipif(not has_directsound, reason="Test requires DirectSound") def test_directsound_listener(): driver = directsound.create_audio_driver() listener = driver.get_listener() check_listener_defaults(listener=listener) check_modifying_values(listener=listener) # Need to garbage collect the listener before the driver is deleted del listener

30.486111

83

0.74123

import pytest from ...annotations import skip_if_continuous_integration try: from pyglet.media.drivers import pulse has_pulse = True except ImportError: has_pulse = False try: from pyglet.media.drivers import openal has_openal = True except ImportError: has_openal = False try: from pyglet.media.drivers import directsound has_directsound = True except ImportError: has_directsound = False def check_listener_defaults(listener): assert listener.volume == 1.0 assert listener.position == (0, 0, 0) assert listener.forward_orientation == (0, 0, -1) assert listener.up_orientation == (0, 1, 0) def check_modifying_values(listener): listener.volume = 0.5 listener.position = (-1, 0, 0) listener.forward_orientation = (0, 0, 1) listener.up_orientation = (0, -1, 0) assert listener.volume == 0.5 assert listener.position == (-1, 0, 0) assert listener.forward_orientation == (0, 0, 1) assert listener.up_orientation == (0, -1, 0) @pytest.mark.skipif(not has_openal, reason="Test requires OpenAL") def test_openal_listener(): driver = openal.create_audio_driver() listener = driver.get_listener() check_listener_defaults(listener=listener) check_modifying_values(listener=listener) del listener @skip_if_continuous_integration() @pytest.mark.skipif(not has_pulse, reason="Test requires PulseAudio") def test_pulse_listener(): driver = pulse.create_audio_driver() listener = driver.get_listener() check_listener_defaults(listener=listener) check_modifying_values(listener=listener) del listener @pytest.mark.skipif(not has_directsound, reason="Test requires DirectSound") def test_directsound_listener(): driver = directsound.create_audio_driver() listener = driver.get_listener() check_listener_defaults(listener=listener) check_modifying_values(listener=listener) del listener

true

f7133e27fe238e02b6a98df99fb4c014baa87fa6

4,306

py

Python

python_modules/libraries/dagster-airflow/dagster_airflow_tests/test_dagster_pipeline_factory/test_tags.py

basilvetas/dagster

b08f5534a0b0277dab38cb7b6a46d324e94b8940

[ "Apache-2.0" ]

2

2021-06-21T17:50:26.000Z

2021-06-21T19:14:23.000Z

python_modules/libraries/dagster-airflow/dagster_airflow_tests/test_dagster_pipeline_factory/test_tags.py

basilvetas/dagster

b08f5534a0b0277dab38cb7b6a46d324e94b8940

[ "Apache-2.0" ]

null

python_modules/libraries/dagster-airflow/dagster_airflow_tests/test_dagster_pipeline_factory/test_tags.py

basilvetas/dagster

b08f5534a0b0277dab38cb7b6a46d324e94b8940

[ "Apache-2.0" ]

1

2021-08-18T17:21:57.000Z

import datetime import os from airflow.models.dag import DAG from airflow.operators.bash_operator import BashOperator from airflow.utils.dates import days_ago from dagster import DagsterEventType, execute_pipeline from dagster.core.instance import AIRFLOW_EXECUTION_DATE_STR from dagster.core.storage.compute_log_manager import ComputeIOType from dagster.core.test_utils import instance_for_test from dagster.seven import get_current_datetime_in_utc from dagster_airflow.dagster_pipeline_factory import make_dagster_pipeline_from_airflow_dag default_args = { "owner": "dagster", "start_date": days_ago(1), } EXECUTION_DATE = get_current_datetime_in_utc() EXECUTION_DATE_MINUS_WEEK = EXECUTION_DATE - datetime.timedelta(days=7) EXECUTION_DATE_FMT = EXECUTION_DATE.strftime("%Y-%m-%d") EXECUTION_DATE_MINUS_WEEK_FMT = EXECUTION_DATE_MINUS_WEEK.strftime("%Y-%m-%d") def normalize_file_content(s): return "\n".join([line for line in s.replace(os.linesep, "\n").split("\n") if line]) def check_compute_logs(manager, result, execution_date_fmt): assert result.success compute_steps = [ event.step_key for event in result.step_event_list if event.event_type == DagsterEventType.STEP_START ] assert compute_steps == [ "airflow_templated.compute", ] for step_key in compute_steps: compute_io_path = manager.get_local_path(result.run_id, step_key, ComputeIOType.STDOUT) assert os.path.exists(compute_io_path) stdout_file = open(compute_io_path, "r") file_contents = normalize_file_content(stdout_file.read()) stdout_file.close() assert ( file_contents.count( "INFO - Running command: \n echo '{execution_date_fmt}'\n".format( execution_date_fmt=execution_date_fmt ) ) == 1 ) assert ( file_contents.count( "INFO - {execution_date_fmt}\n".format(execution_date_fmt=execution_date_fmt) ) == 1 ) assert file_contents.count("INFO - Command exited with return code 0") == 1 def get_dag(): dag = DAG(dag_id="dag", default_args=default_args, schedule_interval=None,) templated_command = """ echo '{{ ds }}' """ # pylint: disable=unused-variable t1 = BashOperator( task_id="templated", depends_on_past=False, bash_command=templated_command, dag=dag, ) return dag def test_pipeline_tags(): dag = get_dag() with instance_for_test() as instance: manager = instance.compute_log_manager # When mode is default and tags are set, run with tags result = execute_pipeline( pipeline=make_dagster_pipeline_from_airflow_dag( dag=dag, tags={AIRFLOW_EXECUTION_DATE_STR: EXECUTION_DATE_MINUS_WEEK_FMT} ), instance=instance, ) check_compute_logs(manager, result, EXECUTION_DATE_MINUS_WEEK_FMT) def test_pipeline_auto_tag(): dag = get_dag() with instance_for_test() as instance: manager = instance.compute_log_manager pre_execute_time = get_current_datetime_in_utc() # When tags are not set, run with current time result = execute_pipeline( pipeline=make_dagster_pipeline_from_airflow_dag(dag=dag), instance=instance, ) post_execute_time = get_current_datetime_in_utc() compute_io_path = manager.get_local_path( result.run_id, "airflow_templated.compute", ComputeIOType.STDOUT ) assert os.path.exists(compute_io_path) stdout_file = open(compute_io_path, "r") file_contents = normalize_file_content(stdout_file.read()) stdout_file.close() search_str = "INFO - Running command: \n echo '" date_start = file_contents.find(search_str) + len(search_str) date_end = date_start + 10 # number of characters in YYYY-MM-DD date = file_contents[date_start:date_end] check_compute_logs(manager, result, date) pre_execute_time_fmt = pre_execute_time.strftime("%Y-%m-%d") post_execute_time_fmt = post_execute_time.strftime("%Y-%m-%d") assert date in [pre_execute_time_fmt, post_execute_time_fmt]

32.37594

95

0.687877

import datetime import os from airflow.models.dag import DAG from airflow.operators.bash_operator import BashOperator from airflow.utils.dates import days_ago from dagster import DagsterEventType, execute_pipeline from dagster.core.instance import AIRFLOW_EXECUTION_DATE_STR from dagster.core.storage.compute_log_manager import ComputeIOType from dagster.core.test_utils import instance_for_test from dagster.seven import get_current_datetime_in_utc from dagster_airflow.dagster_pipeline_factory import make_dagster_pipeline_from_airflow_dag default_args = { "owner": "dagster", "start_date": days_ago(1), } EXECUTION_DATE = get_current_datetime_in_utc() EXECUTION_DATE_MINUS_WEEK = EXECUTION_DATE - datetime.timedelta(days=7) EXECUTION_DATE_FMT = EXECUTION_DATE.strftime("%Y-%m-%d") EXECUTION_DATE_MINUS_WEEK_FMT = EXECUTION_DATE_MINUS_WEEK.strftime("%Y-%m-%d") def normalize_file_content(s): return "\n".join([line for line in s.replace(os.linesep, "\n").split("\n") if line]) def check_compute_logs(manager, result, execution_date_fmt): assert result.success compute_steps = [ event.step_key for event in result.step_event_list if event.event_type == DagsterEventType.STEP_START ] assert compute_steps == [ "airflow_templated.compute", ] for step_key in compute_steps: compute_io_path = manager.get_local_path(result.run_id, step_key, ComputeIOType.STDOUT) assert os.path.exists(compute_io_path) stdout_file = open(compute_io_path, "r") file_contents = normalize_file_content(stdout_file.read()) stdout_file.close() assert ( file_contents.count( "INFO - Running command: \n echo '{execution_date_fmt}'\n".format( execution_date_fmt=execution_date_fmt ) ) == 1 ) assert ( file_contents.count( "INFO - {execution_date_fmt}\n".format(execution_date_fmt=execution_date_fmt) ) == 1 ) assert file_contents.count("INFO - Command exited with return code 0") == 1 def get_dag(): dag = DAG(dag_id="dag", default_args=default_args, schedule_interval=None,) templated_command = """ echo '{{ ds }}' """ t1 = BashOperator( task_id="templated", depends_on_past=False, bash_command=templated_command, dag=dag, ) return dag def test_pipeline_tags(): dag = get_dag() with instance_for_test() as instance: manager = instance.compute_log_manager result = execute_pipeline( pipeline=make_dagster_pipeline_from_airflow_dag( dag=dag, tags={AIRFLOW_EXECUTION_DATE_STR: EXECUTION_DATE_MINUS_WEEK_FMT} ), instance=instance, ) check_compute_logs(manager, result, EXECUTION_DATE_MINUS_WEEK_FMT) def test_pipeline_auto_tag(): dag = get_dag() with instance_for_test() as instance: manager = instance.compute_log_manager pre_execute_time = get_current_datetime_in_utc() result = execute_pipeline( pipeline=make_dagster_pipeline_from_airflow_dag(dag=dag), instance=instance, ) post_execute_time = get_current_datetime_in_utc() compute_io_path = manager.get_local_path( result.run_id, "airflow_templated.compute", ComputeIOType.STDOUT ) assert os.path.exists(compute_io_path) stdout_file = open(compute_io_path, "r") file_contents = normalize_file_content(stdout_file.read()) stdout_file.close() search_str = "INFO - Running command: \n echo '" date_start = file_contents.find(search_str) + len(search_str) date_end = date_start + 10 # number of characters in YYYY-MM-DD date = file_contents[date_start:date_end] check_compute_logs(manager, result, date) pre_execute_time_fmt = pre_execute_time.strftime("%Y-%m-%d") post_execute_time_fmt = post_execute_time.strftime("%Y-%m-%d") assert date in [pre_execute_time_fmt, post_execute_time_fmt]

true

f7133fc12ea31362ad4e7a9eba88862be68ffb9b

4,821

py

Python

tests/rest/client/v1/utils.py

Lrizika/synapse

97174780ce726962ca1beb3788b62f16e9fad270

[ "Apache-2.0" ]

1

2019-06-22T04:17:50.000Z

tests/rest/client/v1/utils.py

fikalefaza/synapse

4f68188d0bbdb1966250375d34125572eb82a117

[ "Apache-2.0" ]

null

tests/rest/client/v1/utils.py

fikalefaza/synapse

4f68188d0bbdb1966250375d34125572eb82a117

[ "Apache-2.0" ]

null

# -*- coding: utf-8 -*- # Copyright 2014-2016 OpenMarket Ltd # # 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 json import time import attr from synapse.api.constants import Membership from tests.server import make_request, render @attr.s class RestHelper(object): """Contains extra helper functions to quickly and clearly perform a given REST action, which isn't the focus of the test. """ hs = attr.ib() resource = attr.ib() auth_user_id = attr.ib() def create_room_as(self, room_creator, is_public=True, tok=None): temp_id = self.auth_user_id self.auth_user_id = room_creator path = "/_matrix/client/r0/createRoom" content = {} if not is_public: content["visibility"] = "private" if tok: path = path + "?access_token=%s" % tok request, channel = make_request( self.hs.get_reactor(), "POST", path, json.dumps(content).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert channel.result["code"] == b"200", channel.result self.auth_user_id = temp_id return channel.json_body["room_id"] def invite(self, room=None, src=None, targ=None, expect_code=200, tok=None): self.change_membership( room=room, src=src, targ=targ, tok=tok, membership=Membership.INVITE, expect_code=expect_code, ) def join(self, room=None, user=None, expect_code=200, tok=None): self.change_membership( room=room, src=user, targ=user, tok=tok, membership=Membership.JOIN, expect_code=expect_code, ) def leave(self, room=None, user=None, expect_code=200, tok=None): self.change_membership( room=room, src=user, targ=user, tok=tok, membership=Membership.LEAVE, expect_code=expect_code, ) def change_membership(self, room, src, targ, membership, tok=None, expect_code=200): temp_id = self.auth_user_id self.auth_user_id = src path = "/_matrix/client/r0/rooms/%s/state/m.room.member/%s" % (room, targ) if tok: path = path + "?access_token=%s" % tok data = {"membership": membership} request, channel = make_request( self.hs.get_reactor(), "PUT", path, json.dumps(data).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert int(channel.result["code"]) == expect_code, ( "Expected: %d, got: %d, resp: %r" % (expect_code, int(channel.result["code"]), channel.result["body"]) ) self.auth_user_id = temp_id def send(self, room_id, body=None, txn_id=None, tok=None, expect_code=200): if txn_id is None: txn_id = "m%s" % (str(time.time())) if body is None: body = "body_text_here" path = "/_matrix/client/r0/rooms/%s/send/m.room.message/%s" % (room_id, txn_id) content = {"msgtype": "m.text", "body": body} if tok: path = path + "?access_token=%s" % tok request, channel = make_request( self.hs.get_reactor(), "PUT", path, json.dumps(content).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert int(channel.result["code"]) == expect_code, ( "Expected: %d, got: %d, resp: %r" % (expect_code, int(channel.result["code"]), channel.result["body"]) ) return channel.json_body def send_state(self, room_id, event_type, body, tok, expect_code=200): path = "/_matrix/client/r0/rooms/%s/state/%s" % (room_id, event_type) if tok: path = path + "?access_token=%s" % tok request, channel = make_request( self.hs.get_reactor(), "PUT", path, json.dumps(body).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert int(channel.result["code"]) == expect_code, ( "Expected: %d, got: %d, resp: %r" % (expect_code, int(channel.result["code"]), channel.result["body"]) ) return channel.json_body

32.795918

88

0.598631

import json import time import attr from synapse.api.constants import Membership from tests.server import make_request, render @attr.s class RestHelper(object): hs = attr.ib() resource = attr.ib() auth_user_id = attr.ib() def create_room_as(self, room_creator, is_public=True, tok=None): temp_id = self.auth_user_id self.auth_user_id = room_creator path = "/_matrix/client/r0/createRoom" content = {} if not is_public: content["visibility"] = "private" if tok: path = path + "?access_token=%s" % tok request, channel = make_request( self.hs.get_reactor(), "POST", path, json.dumps(content).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert channel.result["code"] == b"200", channel.result self.auth_user_id = temp_id return channel.json_body["room_id"] def invite(self, room=None, src=None, targ=None, expect_code=200, tok=None): self.change_membership( room=room, src=src, targ=targ, tok=tok, membership=Membership.INVITE, expect_code=expect_code, ) def join(self, room=None, user=None, expect_code=200, tok=None): self.change_membership( room=room, src=user, targ=user, tok=tok, membership=Membership.JOIN, expect_code=expect_code, ) def leave(self, room=None, user=None, expect_code=200, tok=None): self.change_membership( room=room, src=user, targ=user, tok=tok, membership=Membership.LEAVE, expect_code=expect_code, ) def change_membership(self, room, src, targ, membership, tok=None, expect_code=200): temp_id = self.auth_user_id self.auth_user_id = src path = "/_matrix/client/r0/rooms/%s/state/m.room.member/%s" % (room, targ) if tok: path = path + "?access_token=%s" % tok data = {"membership": membership} request, channel = make_request( self.hs.get_reactor(), "PUT", path, json.dumps(data).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert int(channel.result["code"]) == expect_code, ( "Expected: %d, got: %d, resp: %r" % (expect_code, int(channel.result["code"]), channel.result["body"]) ) self.auth_user_id = temp_id def send(self, room_id, body=None, txn_id=None, tok=None, expect_code=200): if txn_id is None: txn_id = "m%s" % (str(time.time())) if body is None: body = "body_text_here" path = "/_matrix/client/r0/rooms/%s/send/m.room.message/%s" % (room_id, txn_id) content = {"msgtype": "m.text", "body": body} if tok: path = path + "?access_token=%s" % tok request, channel = make_request( self.hs.get_reactor(), "PUT", path, json.dumps(content).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert int(channel.result["code"]) == expect_code, ( "Expected: %d, got: %d, resp: %r" % (expect_code, int(channel.result["code"]), channel.result["body"]) ) return channel.json_body def send_state(self, room_id, event_type, body, tok, expect_code=200): path = "/_matrix/client/r0/rooms/%s/state/%s" % (room_id, event_type) if tok: path = path + "?access_token=%s" % tok request, channel = make_request( self.hs.get_reactor(), "PUT", path, json.dumps(body).encode('utf8') ) render(request, self.resource, self.hs.get_reactor()) assert int(channel.result["code"]) == expect_code, ( "Expected: %d, got: %d, resp: %r" % (expect_code, int(channel.result["code"]), channel.result["body"]) ) return channel.json_body

true

f71341cf49fd61a79c72594e9e57b1e66d251847

491

py

Python

recipes/migrations/0012_auto_20210327_1049.py

backdev96/foodgram-project

dbe7d9a1937bf1a66d9e48fee01009d33ec159e3

[ "MIT" ]

null

recipes/migrations/0012_auto_20210327_1049.py

backdev96/foodgram-project

dbe7d9a1937bf1a66d9e48fee01009d33ec159e3

[ "MIT" ]

null

recipes/migrations/0012_auto_20210327_1049.py

backdev96/foodgram-project

dbe7d9a1937bf1a66d9e48fee01009d33ec159e3

[ "MIT" ]

null

# Generated by Django 3.1.3 on 2021-03-27 10:49 import django.core.validators from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('recipes', '0011_auto_20210327_1046'), ] operations = [ migrations.AlterField( model_name='ingredientrecipe', name='amount', field=models.PositiveIntegerField(null=True, validators=[django.core.validators.MinValueValidator(1)]), ), ]

24.55

115

0.655804

import django.core.validators from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('recipes', '0011_auto_20210327_1046'), ] operations = [ migrations.AlterField( model_name='ingredientrecipe', name='amount', field=models.PositiveIntegerField(null=True, validators=[django.core.validators.MinValueValidator(1)]), ), ]

true

f713423abe187addd46650b41d58c5d3557bd4ed

1,331

py

Python

api/tests/opentrons/protocol_engine/commands/test_move_to_well.py

faliester/opentrons

e945d0f72fed39b0f68c0b30b7afd1981644184f

[ "Apache-2.0" ]

null

api/tests/opentrons/protocol_engine/commands/test_move_to_well.py

faliester/opentrons

e945d0f72fed39b0f68c0b30b7afd1981644184f

[ "Apache-2.0" ]

null

api/tests/opentrons/protocol_engine/commands/test_move_to_well.py

faliester/opentrons

e945d0f72fed39b0f68c0b30b7afd1981644184f

[ "Apache-2.0" ]

null

"""Test move to well commands.""" from mock import AsyncMock # type: ignore[attr-defined] from opentrons.protocol_engine.commands import ( MoveToWellRequest, MoveToWellResult, ) def test_move_to_well_request() -> None: """It should be able to create a MoveToWellRequest.""" request = MoveToWellRequest( pipetteId="abc", labwareId="123", wellName="A3", ) assert request.pipetteId == "abc" assert request.labwareId == "123" assert request.wellName == "A3" def test_move_to_well_result() -> None: """It should be able to create a MoveToWellResult.""" # NOTE(mc, 2020-11-17): this model has no properties at this time result = MoveToWellResult() assert result async def test_move_to_well_implementation(mock_handlers: AsyncMock) -> None: """A MoveToWellRequest should have an execution implementation.""" mock_handlers.movement.move_to_well.return_value = None request = MoveToWellRequest( pipetteId="abc", labwareId="123", wellName="A3", ) impl = request.get_implementation() result = await impl.execute(mock_handlers) assert result == MoveToWellResult() mock_handlers.movement.move_to_well.assert_called_with( pipette_id="abc", labware_id="123", well_name="A3", )

26.62

77

0.677686

from mock import AsyncMock from opentrons.protocol_engine.commands import ( MoveToWellRequest, MoveToWellResult, ) def test_move_to_well_request() -> None: request = MoveToWellRequest( pipetteId="abc", labwareId="123", wellName="A3", ) assert request.pipetteId == "abc" assert request.labwareId == "123" assert request.wellName == "A3" def test_move_to_well_result() -> None: result = MoveToWellResult() assert result async def test_move_to_well_implementation(mock_handlers: AsyncMock) -> None: mock_handlers.movement.move_to_well.return_value = None request = MoveToWellRequest( pipetteId="abc", labwareId="123", wellName="A3", ) impl = request.get_implementation() result = await impl.execute(mock_handlers) assert result == MoveToWellResult() mock_handlers.movement.move_to_well.assert_called_with( pipette_id="abc", labware_id="123", well_name="A3", )

true

f7134253219dda7a96ba9d674364c61f4ce448e8

1,370

py

Python

Heron/Operations/Sources/Input/User_Input/user_input_com.py

Heron-Repositories/Heron

d63c907096fb00435a493cbfa5a5ad1a61f6cf2e

[ "MIT" ]

1

2022-03-27T06:03:09.000Z

Heron/Operations/Sources/Input/User_Input/user_input_com.py

Heron-Repositories/Heron

d63c907096fb00435a493cbfa5a5ad1a61f6cf2e

[ "MIT" ]

null

Heron/Operations/Sources/Input/User_Input/user_input_com.py

Heron-Repositories/Heron

d63c907096fb00435a493cbfa5a5ad1a61f6cf2e

[ "MIT" ]

null

import os import sys from os import path current_dir = path.dirname(path.abspath(__file__)) while path.split(current_dir)[-1] != r'Heron': current_dir = path.dirname(current_dir) sys.path.insert(0, path.dirname(current_dir)) from Heron import general_utils as gu Exec = os.path.abspath(__file__) # <editor-fold desc="The following code is called from the GUI process as part of the generation of the node. # It is meant to create node specific elements (not part of a generic node). # This is where a new nodes individual elements should be defined"> """ Properties of the generated Node """ BaseName = 'User Input' NodeAttributeNames = ['Parameters', 'Text Out'] NodeAttributeType = ['Static', 'Output'] ParameterNames = ['Visualisation', 'Output Type', 'User Input'] ParameterTypes = ['bool', 'list', 'str'] ParametersDefaultValues = [False, ['string', 'int', 'float'], ''] WorkerDefaultExecutable = os.path.join(os.path.dirname(Exec), 'user_input_worker.py') # </editor-fold> # <editor-fold desc="The following code is called as its own process when the editor starts the graph"> if __name__ == "__main__": user_input_com = gu.start_the_source_communications_process(NodeAttributeType, NodeAttributeNames) gu.register_exit_signals(user_input_com.on_kill) user_input_com.start_ioloop() # </editor-fold>

34.25

110

0.727737

import os import sys from os import path current_dir = path.dirname(path.abspath(__file__)) while path.split(current_dir)[-1] != r'Heron': current_dir = path.dirname(current_dir) sys.path.insert(0, path.dirname(current_dir)) from Heron import general_utils as gu Exec = os.path.abspath(__file__) # It is meant to create node specific elements (not part of a generic node). # This is where a new nodes individual elements should be defined"> BaseName = 'User Input' NodeAttributeNames = ['Parameters', 'Text Out'] NodeAttributeType = ['Static', 'Output'] ParameterNames = ['Visualisation', 'Output Type', 'User Input'] ParameterTypes = ['bool', 'list', 'str'] ParametersDefaultValues = [False, ['string', 'int', 'float'], ''] WorkerDefaultExecutable = os.path.join(os.path.dirname(Exec), 'user_input_worker.py') if __name__ == "__main__": user_input_com = gu.start_the_source_communications_process(NodeAttributeType, NodeAttributeNames) gu.register_exit_signals(user_input_com.on_kill) user_input_com.start_ioloop()

true

f7134319b026f17ce563d94428a6c60bc1549970

496

py

Python

simply_block/sample/request_multi_form.py

simplyblock/sb-python-sdk

9c951021ec64359e726dc9d4bb933109c9d4aced

[ "MIT" ]

null

simply_block/sample/request_multi_form.py

simplyblock/sb-python-sdk

9c951021ec64359e726dc9d4bb933109c9d4aced

[ "MIT" ]

null

simply_block/sample/request_multi_form.py

simplyblock/sb-python-sdk

9c951021ec64359e726dc9d4bb933109c9d4aced

[ "MIT" ]

null

from simply_block.simply_sign import SimplySign # Token public_key = "hmac_pub_1" private_key = "hmac_priv_1" # Required Params url = "http://127.0.0.1:8000/v1/eth/contract/build/" file_path = "/home/lenovo/Documents/simplyblock/ethereum-service/contracts/DappToken.sol" data = { 'contract_name': 'contract_22' } files = { 'contract': file_path } # Request response = SimplySign(private_key, public_key).gateway_request(url, data, files=files) print(response) print(response.text)

23.619048

89

0.75

from simply_block.simply_sign import SimplySign public_key = "hmac_pub_1" private_key = "hmac_priv_1" url = "http://127.0.0.1:8000/v1/eth/contract/build/" file_path = "/home/lenovo/Documents/simplyblock/ethereum-service/contracts/DappToken.sol" data = { 'contract_name': 'contract_22' } files = { 'contract': file_path } response = SimplySign(private_key, public_key).gateway_request(url, data, files=files) print(response) print(response.text)

true

f713446a1b0ac2f40a206550d7fd9db0889c46ab

418

py

Python

groups/urls.py

aryasadeghy/simpleSocial

46c1f83a07817efbd095507303c66353fe1ae932

[ "MIT" ]

null

groups/urls.py

aryasadeghy/simpleSocial

46c1f83a07817efbd095507303c66353fe1ae932

[ "MIT" ]

6

2020-02-11T22:54:25.000Z

2022-01-13T00:47:14.000Z

groups/urls.py

aryasadeghy/simpleSocial

46c1f83a07817efbd095507303c66353fe1ae932

[ "MIT" ]

null

from django.urls import path,re_path from groups import views app_name = 'groups' urlpatterns = [ path('',views.ListGroup.as_view(), name= 'all'), path('new/',views.CreateGroup.as_view(), name='create'), path('posts/in/<slug>/',views.SingleGroup.as_view(),name='single'), path('join/<slug>/',views.JoinGroup.as_view(),name='join'), path('leave/<slug>/', views.LeaveGroup.as_view(),name='leave') ]

34.833333

71

0.674641

from django.urls import path,re_path from groups import views app_name = 'groups' urlpatterns = [ path('',views.ListGroup.as_view(), name= 'all'), path('new/',views.CreateGroup.as_view(), name='create'), path('posts/in/<slug>/',views.SingleGroup.as_view(),name='single'), path('join/<slug>/',views.JoinGroup.as_view(),name='join'), path('leave/<slug>/', views.LeaveGroup.as_view(),name='leave') ]

true

f71345bdd90d83927cff0f0a35d5e1680efb8975

2,769

py

Python

src/raumfeldskill.py

THaeckel/PyHomeAutomate

b66715effa27533765a114b588ee6a93c37117aa

[ "MIT" ]

null

src/raumfeldskill.py

THaeckel/PyHomeAutomate

b66715effa27533765a114b588ee6a93c37117aa

[ "MIT" ]

null

src/raumfeldskill.py

THaeckel/PyHomeAutomate

b66715effa27533765a114b588ee6a93c37117aa

[ "MIT" ]

null

""" Skills to control teufel raumfeld streaming devices RaumfeldTVWakeup is a Skill that wakes up a speaker when the TV is turned on. Copyright (c) 2021 Timo Haeckel """ from skills import SkillWithState import raumfeld RAUMFELD_URI_PLACEHOLDER = "dlna-playcontainer://uuid%3Abd4f7f00-aa40-4e4a-a54e-ec64e9944e23?sid=urn%3Aupnp-org%3AserviceId%3AContentDirectory&cid=0%2FTidal%2FDirectAccess%2FArtist%2F8372%2FTopTracks&fid=0&fii=0" class RaumfeldTVWakeup(SkillWithState): """ Skill to wakeup a raumfeld speaker connected to a smart tv. This skill wakes up the raumfeld speaker connected to the smart tv when it is turned on. Settings -------- { "statePrefix" : "DevicePresence:", "tvAddress" : "192.168.178.42", "tvSpeakerRoomName" : "TV Speaker" } Attributes ---------- tvAddress : str The TVs IPv4 address to be detected in the local network. STATE_PREFIX : str The prefix from the DeviceDetectionSkill used to form the state key in the state data base for the tv host with STATE_PREFIX + Address """ def __init__(self, statedb, settingsFile=""): """ Parameters ---------- statedb : statedb.StateDataBase The shared state data base instance used for all skills in the home automation setup settingsFile : str Path to the global skill settings file """ SkillWithState.__init__(self, name="RaumfeldTVWakeup", statedb=statedb, settingsFile=settingsFile) raumfeld.init() self.alreadyAwake = False self.speaker = self.findSkillSettingWithKey("tvSpeakerRoomName") self.tvAddress = self.findSkillSettingWithKey("tvAddress") self.STATE_PREFIX = self.findSkillSettingWithKey("statePrefix") def wakeup(self, speaker): rooms = raumfeld.getRoomsByName(speaker) rooms[0].play(RAUMFELD_URI_PLACEHOLDER) rooms[0].pause() def task(self): """ Wakeup TV speakers task This function will wakeup the TV speakers if the TV device is turned on """ tvState = self.readState(self.STATE_PREFIX + self.tvAddress) if tvState is not None: if tvState.currentlyPresent: #tv is turned on! if not self.alreadyAwake: self.wakeup(self.speaker) self.alreadyAwake = True self.log("TV Speaker woken up") elif self.alreadyAwake: #tv turned off! self.alreadyAwake = False self.log("TV turned off sleep allowed")

35.050633

224

0.618996

from skills import SkillWithState import raumfeld RAUMFELD_URI_PLACEHOLDER = "dlna-playcontainer://uuid%3Abd4f7f00-aa40-4e4a-a54e-ec64e9944e23?sid=urn%3Aupnp-org%3AserviceId%3AContentDirectory&cid=0%2FTidal%2FDirectAccess%2FArtist%2F8372%2FTopTracks&fid=0&fii=0" class RaumfeldTVWakeup(SkillWithState): def __init__(self, statedb, settingsFile=""): SkillWithState.__init__(self, name="RaumfeldTVWakeup", statedb=statedb, settingsFile=settingsFile) raumfeld.init() self.alreadyAwake = False self.speaker = self.findSkillSettingWithKey("tvSpeakerRoomName") self.tvAddress = self.findSkillSettingWithKey("tvAddress") self.STATE_PREFIX = self.findSkillSettingWithKey("statePrefix") def wakeup(self, speaker): rooms = raumfeld.getRoomsByName(speaker) rooms[0].play(RAUMFELD_URI_PLACEHOLDER) rooms[0].pause() def task(self): tvState = self.readState(self.STATE_PREFIX + self.tvAddress) if tvState is not None: if tvState.currentlyPresent: if not self.alreadyAwake: self.wakeup(self.speaker) self.alreadyAwake = True self.log("TV Speaker woken up") elif self.alreadyAwake: self.alreadyAwake = False self.log("TV turned off sleep allowed")

true

f713479d7e86c1f3878f269fe0ca8474d445ef34

20,667

py

Python

collector/example/rpcclient/netflowlib.py

codragonzuo/beats

b5a8449e21a038bc82dde6cac5fd4ec20df32b07

[ "ECL-2.0", "Apache-2.0" ]

null

collector/example/rpcclient/netflowlib.py

codragonzuo/beats

b5a8449e21a038bc82dde6cac5fd4ec20df32b07

[ "ECL-2.0", "Apache-2.0" ]

null

collector/example/rpcclient/netflowlib.py

codragonzuo/beats

b5a8449e21a038bc82dde6cac5fd4ec20df32b07

[ "ECL-2.0", "Apache-2.0" ]

null

""" This file belongs to https://github.com/bitkeks/python-netflow-v9-softflowd. The test packets (defined below as hex streams) were extracted from "real" softflowd exports based on a sample PCAP capture file. Copyright 2016-2020 Dominik Pataky <software+pynetflow@dpataky.eu> Licensed under MIT License. See LICENSE. """ # The flowset with 2 templates (IPv4 and IPv6) and 8 flows with data import queue import random import socket import time #from netflow.collector import ThreadedNetFlowListener # Invalid export hex stream PACKET_INVALID = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" CONNECTION = ('127.0.0.1', 1337) NUM_PACKETS = 1000 def gen_pkts(n, idx): for x in range(n): if x == idx: yield PACKET_V9_TEMPLATE else: yield random.choice(PACKETS_V9) def emit_packets(packets, delay=0.0001): """Send the provided packets to the listener""" sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for p in packets: sock.sendto(bytes.fromhex(p), CONNECTION) time.sleep(delay) sock.close() def send_packets(packets, delay=0.0001, store_packets=-1) -> (list, float, float): """Starts a listener, send packets, receives packets returns a tuple: ([(ts, export), ...], time_started_sending, time_stopped_sending) """ #listener = ThreadedNetFlowListener(*CONNECTION) tstart = time.time() emit_packets(packets, delay=delay) time.sleep(0.5) # Allow packets to be sent and recieved tend = time.time() #listener.start() """ def send_recv_packets(packets, delay=0.0001, store_packets=-1) -> (list, float, float): listener = ThreadedNetFlowListener(*CONNECTION) tstart = time.time() emit_packets(packets, delay=delay) time.sleep(0.5) # Allow packets to be sent and recieved tend = time.time() listener.start() pkts = [] to_pad = 0 while True: try: packet = listener.get(timeout=0.5) if -1 == store_packets or store_packets > 0: # Case where a programm yields from the queue and stores all packets. pkts.append(packet) if store_packets != -1 and len(pkts) > store_packets: to_pad += len(pkts) # Hack for testing pkts.clear() else: # Performance measurements for cases where yielded objects are processed # immediatelly instead of stored. Add empty tuple to retain counting possibility. pkts.append(()) except queue.Empty: break listener.stop() listener.join() if to_pad > 0: pkts = [()] * to_pad + pkts return pkts, tstart, tend """ def generate_packets(amount, version, template_every_x=100): packets = [PACKET_IPFIX] template = PACKET_IPFIX_TEMPLATE if version == 1: packets = [PACKET_V1] elif version == 5: packets = [PACKET_V5] elif version == 9: packets = [*PACKETS_V9] template = PACKET_V9_TEMPLATE if amount < template_every_x: template_every_x = 10 # If the list of test packets is only one item big (the same packet is used over and over), # do not use random.choice - it costs performance and results in the same packet every time. def single_packet(pkts): return pkts[0] packet_func = single_packet if len(packets) > 1: packet_func = random.choice for x in range(amount): if x % template_every_x == 0 and version in [9, 10]: # First packet always a template, then periodically # Note: this was once based on random.random, but it costs performance yield template else: yield packet_func(packets) # Example export for v1 which contains two flows from one ICMP ping request/reply session PACKET_V1 = "000100020001189b5e80c32c2fd41848ac110002ac11000100000000000000000000000a00000348" \ "000027c700004af100000800000001000000000000000000ac110001ac1100020000000000000000" \ "0000000a00000348000027c700004af100000000000001000000000000000000" # Example export for v5 which contains three flows, two for ICMP ping and one multicast on interface (224.0.0.251) PACKET_V5 = "00050003000379a35e80c58622a55ab00000000000000000ac110002ac1100010000000000000000" \ "0000000a0000034800002f4c0000527600000800000001000000000000000000ac110001ac110002" \ "00000000000000000000000a0000034800002f4c0000527600000000000001000000000000000000" \ "ac110001e00000fb000000000000000000000001000000a90000e01c0000e01c14e914e900001100" \ "0000000000000000" PACKET_V9_TEMPLATE = "0009000a000000035c9f55980000000100000000000000400400000e00080004000c000400150004" \ "001600040001000400020004000a0004000e000400070002000b00020004000100060001003c0001" \ "00050001000000400800000e001b0010001c001000150004001600040001000400020004000a0004" \ "000e000400070002000b00020004000100060001003c000100050001040001447f0000017f000001" \ "fb3c1aaafb3c18fd000190100000004b00000000000000000050942c061b04007f0000017f000001" \ "fb3c1aaafb3c18fd00000f94000000360000000000000000942c0050061f04007f0000017f000001" \ "fb3c1cfcfb3c1a9b0000d3fc0000002a000000000000000000509434061b04007f0000017f000001" \ "fb3c1cfcfb3c1a9b00000a490000001e000000000000000094340050061f04007f0000017f000001" \ "fb3bb82cfb3ba48b000002960000000300000000000000000050942a061904007f0000017f000001" \ "fb3bb82cfb3ba48b00000068000000020000000000000000942a0050061104007f0000017f000001" \ "fb3c1900fb3c18fe0000004c0000000100000000000000000035b3c9110004007f0000017f000001" \ "fb3c1900fb3c18fe0000003c000000010000000000000000b3c9003511000400" # This packet is special. We take PACKET_V9_TEMPLATE and re-order the templates and flows. # The first line is the header, the smaller lines the templates and the long lines the flows (limited to 80 chars) PACKET_V9_TEMPLATE_MIXED = ("0009000a000000035c9f55980000000100000000" # header "040001447f0000017f000001fb3c1aaafb3c18fd000190100000004b00000000000000000050942c" "061b04007f0000017f000001fb3c1aaafb3c18fd00000f94000000360000000000000000942c0050" "061f04007f0000017f000001fb3c1cfcfb3c1a9b0000d3fc0000002a000000000000000000509434" "061b04007f0000017f000001fb3c1cfcfb3c1a9b00000a490000001e000000000000000094340050" "061f04007f0000017f000001fb3bb82cfb3ba48b000002960000000300000000000000000050942a" "061904007f0000017f000001fb3bb82cfb3ba48b00000068000000020000000000000000942a0050" "061104007f0000017f000001fb3c1900fb3c18fe0000004c0000000100000000000000000035b3c9" "110004007f0000017f000001fb3c1900fb3c18fe0000003c000000010000000000000000b3c90035" "11000400" # end of flow segments "000000400400000e00080004000c000400150004001600040001000400020004" # template 1024 "000a0004000e000400070002000b00020004000100060001003c000100050001" "000000400800000e001b0010001c001000150004001600040001000400020004" # template 2048 "000a0004000e000400070002000b00020004000100060001003c000100050001") # Three packets without templates, each with 12 flows PACKETS_V9 = [ "0009000c000000035c9f55980000000200000000040001e47f0000017f000001fb3c1a17fb3c19fd" "000001480000000200000000000000000035ea82110004007f0000017f000001fb3c1a17fb3c19fd" "0000007a000000020000000000000000ea820035110004007f0000017f000001fb3c1a17fb3c19fd" "000000f80000000200000000000000000035c6e2110004007f0000017f000001fb3c1a17fb3c19fd" "0000007a000000020000000000000000c6e20035110004007f0000017f000001fb3c1a9efb3c1a9c" "0000004c0000000100000000000000000035adc1110004007f0000017f000001fb3c1a9efb3c1a9c" "0000003c000000010000000000000000adc10035110004007f0000017f000001fb3c1b74fb3c1b72" "0000004c0000000100000000000000000035d0b3110004007f0000017f000001fb3c1b74fb3c1b72" "0000003c000000010000000000000000d0b30035110004007f0000017f000001fb3c2f59fb3c1b71" "00001a350000000a000000000000000000509436061b04007f0000017f000001fb3c2f59fb3c1b71" "0000038a0000000a000000000000000094360050061b04007f0000017f000001fb3c913bfb3c9138" "0000004c0000000100000000000000000035e262110004007f0000017f000001fb3c913bfb3c9138" "0000003c000000010000000000000000e262003511000400", "0009000c000000035c9f55980000000300000000040001e47f0000017f000001fb3ca523fb3c913b" "0000030700000005000000000000000000509438061b04007f0000017f000001fb3ca523fb3c913b" "000002a200000005000000000000000094380050061b04007f0000017f000001fb3f7fe1fb3dbc97" "0002d52800000097000000000000000001bb8730061b04007f0000017f000001fb3f7fe1fb3dbc97" "0000146c000000520000000000000000873001bb061f04007f0000017f000001fb3d066ffb3d066c" "0000004c0000000100000000000000000035e5bd110004007f0000017f000001fb3d066ffb3d066c" "0000003c000000010000000000000000e5bd0035110004007f0000017f000001fb3d1a61fb3d066b" "000003060000000500000000000000000050943a061b04007f0000017f000001fb3d1a61fb3d066b" "000002a2000000050000000000000000943a0050061b04007f0000017f000001fb3fed00fb3f002c" "0000344000000016000000000000000001bbae50061f04007f0000017f000001fb3fed00fb3f002c" "00000a47000000120000000000000000ae5001bb061b04007f0000017f000001fb402f17fb402a75" "0003524c000000a5000000000000000001bbc48c061b04007f0000017f000001fb402f17fb402a75" "000020a60000007e0000000000000000c48c01bb061f0400", "0009000c000000035c9f55980000000400000000040001e47f0000017f000001fb3d7ba2fb3d7ba0" "0000004c0000000100000000000000000035a399110004007f0000017f000001fb3d7ba2fb3d7ba0" "0000003c000000010000000000000000a3990035110004007f0000017f000001fb3d8f85fb3d7b9f" "000003070000000500000000000000000050943c061b04007f0000017f000001fb3d8f85fb3d7b9f" "000002a2000000050000000000000000943c0050061b04007f0000017f000001fb3d9165fb3d7f6d" "0000c97b0000002a000000000000000001bbae48061b04007f0000017f000001fb3d9165fb3d7f6d" "000007f40000001a0000000000000000ae4801bb061b04007f0000017f000001fb3dbc96fb3dbc7e" "0000011e0000000200000000000000000035bd4f110004007f0000017f000001fb3dbc96fb3dbc7e" "0000008e000000020000000000000000bd4f0035110004007f0000017f000001fb3ddbb3fb3c1a18" "0000bfee0000002f00000000000000000050ae56061b04007f0000017f000001fb3ddbb3fb3c1a18" "00000982000000270000000000000000ae560050061b04007f0000017f000001fb3ddbb3fb3c1a18" "0000130e0000001200000000000000000050e820061b04007f0000017f000001fb3ddbb3fb3c1a18" "0000059c000000140000000000000000e8200050061b0400" ] # Example export for IPFIX (v10) with 4 templates, 1 option template and 8 data flow sets PACKET_IPFIX_TEMPLATE = "000a05202d45a4700000001300000000000200400400000e00080004000c00040016000400150004" \ "0001000400020004000a0004000e000400070002000b00020004000100060001003c000100050001" \ "000200340401000b00080004000c000400160004001500040001000400020004000a0004000e0004" \ "00200002003c000100050001000200400800000e001b0010001c0010001600040015000400010004" \ "00020004000a0004000e000400070002000b00020004000100060001003c00010005000100020034" \ "0801000b001b0010001c001000160004001500040001000400020004000a0004000e0004008b0002" \ "003c0001000500010003001e010000050001008f000400a000080131000401320004013000020100" \ "001a00000a5900000171352e672100000001000000000001040000547f000001ac110002ff7ed688" \ "ff7ed73a000015c70000000d000000000000000001bbe1a6061b0400ac1100027f000001ff7ed688" \ "ff7ed73a0000074f000000130000000000000000e1a601bb061f04000401004cac110002ac110001" \ "ff7db9e0ff7dc1d0000000fc00000003000000000000000008000400ac110001ac110002ff7db9e0" \ "ff7dc1d0000000fc0000000300000000000000000000040008010220fde66f14e0f1960900000242" \ "ac110002ff0200000000000000000001ff110001ff7dfad6ff7e0e95000001b00000000600000000" \ "0000000087000600fde66f14e0f196090000affeaffeaffefdabcdef123456789000000000000001" \ "ff7e567fff7e664a0000020800000005000000000000000080000600fde66f14e0f1960900000000" \ "00000001fde66f14e0f196090000affeaffeaffeff7e567fff7e664a000002080000000500000000" \ "0000000081000600fe800000000000000042aafffe73bbfafde66f14e0f196090000affeaffeaffe" \ "ff7e6aaaff7e6aaa0000004800000001000000000000000087000600fde66f14e0f1960900000242" \ "ac110002fe800000000000000042aafffe73bbfaff7e6aaaff7e6aaa000000400000000100000000" \ "0000000088000600fe800000000000000042acfffe110002fe800000000000000042aafffe73bbfa" \ "ff7e7eaaff7e7eaa0000004800000001000000000000000087000600fe800000000000000042aaff" \ "fe73bbfafe800000000000000042acfffe110002ff7e7eaaff7e7eaa000000400000000100000000" \ "0000000088000600fe800000000000000042aafffe73bbfafe800000000000000042acfffe110002" \ "ff7e92aaff7e92aa0000004800000001000000000000000087000600fe800000000000000042acff" \ "fe110002fe800000000000000042aafffe73bbfaff7e92aaff7e92aa000000400000000100000000" \ "000000008800060008000044fde66f14e0f196090000affeaffeaffefd41b7143f86000000000000" \ "00000001ff7ec2a0ff7ec2a00000004a000000010000000000000000d20100351100060004000054" \ "ac1100027f000001ff7ed62eff7ed68700000036000000010000000000000000c496003511000400" \ "7f000001ac110002ff7ed62eff7ed687000000760000000100000000000000000035c49611000400" \ "08000044fde66f14e0f196090000affeaffeaffefd41b7143f8600000000000000000001ff7ef359" \ "ff7ef3590000004a000000010000000000000000b1e700351100060004000054ac1100027f000001" \ "ff7f06e4ff7f06e800000036000000010000000000000000a8f90035110004007f000001ac110002" \ "ff7f06e4ff7f06e8000000a60000000100000000000000000035a8f911000400" # Example export for IPFIX with two data sets PACKET_IPFIX = "000a00d02d45a47000000016000000000801007cfe800000000000000042acfffe110002fde66f14" \ "e0f196090000000000000001ff7f0755ff7f07550000004800000001000000000000000087000600" \ "fdabcdef123456789000000000000001fe800000000000000042acfffe110002ff7f0755ff7f0755" \ "000000400000000100000000000000008800060008000044fde66f14e0f196090000affeaffeaffe" \ "2a044e42020000000000000000000223ff7f06e9ff7f22d500000140000000040000000000000000" \ "e54c01bb06020600" PACKET_IPFIX_TEMPLATE_ETHER = "000a05002d45a4700000000d00000000" \ "000200500400001200080004000c000400160004001500040001000400020004000a0004000e0004" \ "00070002000b00020004000100060001003c000100050001003a0002003b00020038000600390006" \ "000200440401000f00080004000c000400160004001500040001000400020004000a0004000e0004" \ "00200002003c000100050001003a0002003b000200380006003900060002005008000012001b0010" \ "001c001000160004001500040001000400020004000a0004000e000400070002000b000200040001" \ "00060001003c000100050001003a0002003b00020038000600390006000200440801000f001b0010" \ "001c001000160004001500040001000400020004000a0004000e0004008b0002003c000100050001" \ "003a0002003b000200380006003900060003001e010000050001008f000400a00008013100040132" \ "0004013000020100001a00000009000000b0d80a558000000001000000000001040000747f000001" \ "ac110002e58b988be58b993e000015c70000000d000000000000000001bbe1a6061b040000000000" \ "123456affefeaffeaffeaffeac1100027f000001e58b988be58b993e0000074f0000001300000000" \ "00000000e1a601bb061f040000000000affeaffeaffe123456affefe0401006cac110002ac110001" \ "e58a7be3e58a83d3000000fc0000000300000000000000000800040000000000affeaffeaffe0242" \ "aa73bbfaac110001ac110002e58a7be3e58a83d3000000fc00000003000000000000000000000400" \ "00000000123456affefeaffeaffeaffe080102b0fde66f14e0f196090000affeaffeaffeff020000" \ "0000000000000001ff110001e58abcd9e58ad098000001b000000006000000000000000087000600" \ "00000000affeaffeaffe3333ff110001fde66f14e0f196090000affeaffeaffefde66f14e0f19609" \ "0000000000000001e58b1883e58b284e000002080000000500000000000000008000060000000000" \ "affeaffeaffe123456affefefdabcdef123456789000000000000001fde66f14e0f1960900000242" \ "ac110002e58b1883e58b284e0000020800000005000000000000000081000600000000000242aa73" \ "bbfaaffeaffeaffefe800000000000000042aafffe73bbfafde66f14e0f196090000affeaffeaffe" \ "e58b2caee58b2cae000000480000000100000000000000008700060000000000123456affefe0242" \ "ac110002fde66f14e0f196090000affeaffeaffefe800000000000000042aafffe73bbfae58b2cae" \ "e58b2cae000000400000000100000000000000008800060000000000affeaffeaffe123456affefe" \ "fe800000000000000042acfffe110002fe800000000000000042aafffe73bbfae58b40aee58b40ae" \ "000000480000000100000000000000008700060000000000affeaffeaffe123456affefefe800000" \ "000000000042aafffe73bbfafe800000000000000042acfffe110002e58b40aee58b40ae00000040" \ "0000000100000000000000008800060000000000123456affefeaffeaffeaffefe80000000000000" \ "0042aafffe73bbfafe800000000000000042acfffe110002e58b54aee58b54ae0000004800000001" \ "00000000000000008700060000000000123456affefeaffeaffeaffefe800000000000000042acff" \ "fe110002fe800000000000000042aafffe73bbfae58b54aee58b54ae000000400000000100000000" \ "000000008800060000000000affeaffeaffe123456affefe" PACKET_IPFIX_ETHER = "000a02905e8b0aa90000001600000000" \ "08000054fde66f14e0f196090000affeaffeaffefd40abcdabcd00000000000000011111e58b84a4" \ "e58b84a40000004a000000010000000000000000d20100351100060000000000affeaffeaffe0242" \ "aa73bbfa04000074ac1100027f000001e58b9831e58b988a00000036000000010000000000000000" \ "c49600351100040000000000affeaffeaffe123456affefe7f000001ac110002e58b9831e58b988a" \ "000000760000000100000000000000000035c4961100040000000000123456affefeaffeaffeaffe" \ "08000054fde66f14e0f196090000affeaffeaffefd40abcdabcd00000000000000011111e58bb55c" \ "e58bb55c0000004a000000010000000000000000b1e700351100060000000000affeaffeaffe0242" \ "aa73bbfa04000074ac1100027f000001e58bc8e8e58bc8ec00000036000000010000000000000000" \ "a8f900351100040000000000affeaffeaffe123456affefe7f000001ac110002e58bc8e8e58bc8ec" \ "000000a60000000100000000000000000035a8f91100040000000000123456affefeaffeaffeaffe" \ "0801009cfe800000000000000042acfffe110002fdabcdef123456789000000000000001e58bc958" \ "e58bc958000000480000000100000000000000008700060000000000affeaffeaffe123456affefe" \ "fdabcdef123456789000000000000001fe800000000000000042acfffe110002e58bc958e58bc958" \ "000000400000000100000000000000008800060000000000123456affefeaffeaffeaffe08000054" \ "fde66f14e0f196090000affeaffeaffe2a044e42020000000000000000000223e58bc8ede58be4d8" \ "00000140000000040000000000000000e54c01bb0602060000000000affeaffeaffe123456affefe"

67.760656

114

0.749504

import queue import random import socket import time PACKET_INVALID = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" CONNECTION = ('127.0.0.1', 1337) NUM_PACKETS = 1000 def gen_pkts(n, idx): for x in range(n): if x == idx: yield PACKET_V9_TEMPLATE else: yield random.choice(PACKETS_V9) def emit_packets(packets, delay=0.0001): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for p in packets: sock.sendto(bytes.fromhex(p), CONNECTION) time.sleep(delay) sock.close() def send_packets(packets, delay=0.0001, store_packets=-1) -> (list, float, float): tstart = time.time() emit_packets(packets, delay=delay) time.sleep(0.5) tend = time.time() def generate_packets(amount, version, template_every_x=100): packets = [PACKET_IPFIX] template = PACKET_IPFIX_TEMPLATE if version == 1: packets = [PACKET_V1] elif version == 5: packets = [PACKET_V5] elif version == 9: packets = [*PACKETS_V9] template = PACKET_V9_TEMPLATE if amount < template_every_x: template_every_x = 10 def single_packet(pkts): return pkts[0] packet_func = single_packet if len(packets) > 1: packet_func = random.choice for x in range(amount): if x % template_every_x == 0 and version in [9, 10]: yield template else: yield packet_func(packets) PACKET_V1 = "000100020001189b5e80c32c2fd41848ac110002ac11000100000000000000000000000a00000348" \ "000027c700004af100000800000001000000000000000000ac110001ac1100020000000000000000" \ "0000000a00000348000027c700004af100000000000001000000000000000000" PACKET_V5 = "00050003000379a35e80c58622a55ab00000000000000000ac110002ac1100010000000000000000" \ "0000000a0000034800002f4c0000527600000800000001000000000000000000ac110001ac110002" \ "00000000000000000000000a0000034800002f4c0000527600000000000001000000000000000000" \ "ac110001e00000fb000000000000000000000001000000a90000e01c0000e01c14e914e900001100" \ "0000000000000000" PACKET_V9_TEMPLATE = "0009000a000000035c9f55980000000100000000000000400400000e00080004000c000400150004" \ "001600040001000400020004000a0004000e000400070002000b00020004000100060001003c0001" \ "00050001000000400800000e001b0010001c001000150004001600040001000400020004000a0004" \ "000e000400070002000b00020004000100060001003c000100050001040001447f0000017f000001" \ "fb3c1aaafb3c18fd000190100000004b00000000000000000050942c061b04007f0000017f000001" \ "fb3c1aaafb3c18fd00000f94000000360000000000000000942c0050061f04007f0000017f000001" \ "fb3c1cfcfb3c1a9b0000d3fc0000002a000000000000000000509434061b04007f0000017f000001" \ "fb3c1cfcfb3c1a9b00000a490000001e000000000000000094340050061f04007f0000017f000001" \ "fb3bb82cfb3ba48b000002960000000300000000000000000050942a061904007f0000017f000001" \ "fb3bb82cfb3ba48b00000068000000020000000000000000942a0050061104007f0000017f000001" \ "fb3c1900fb3c18fe0000004c0000000100000000000000000035b3c9110004007f0000017f000001" \ "fb3c1900fb3c18fe0000003c000000010000000000000000b3c9003511000400" PACKET_V9_TEMPLATE_MIXED = ("0009000a000000035c9f55980000000100000000" "040001447f0000017f000001fb3c1aaafb3c18fd000190100000004b00000000000000000050942c" "061b04007f0000017f000001fb3c1aaafb3c18fd00000f94000000360000000000000000942c0050" "061f04007f0000017f000001fb3c1cfcfb3c1a9b0000d3fc0000002a000000000000000000509434" "061b04007f0000017f000001fb3c1cfcfb3c1a9b00000a490000001e000000000000000094340050" "061f04007f0000017f000001fb3bb82cfb3ba48b000002960000000300000000000000000050942a" "061904007f0000017f000001fb3bb82cfb3ba48b00000068000000020000000000000000942a0050" "061104007f0000017f000001fb3c1900fb3c18fe0000004c0000000100000000000000000035b3c9" "110004007f0000017f000001fb3c1900fb3c18fe0000003c000000010000000000000000b3c90035" "11000400" "000000400400000e00080004000c000400150004001600040001000400020004" "000a0004000e000400070002000b00020004000100060001003c000100050001" "000000400800000e001b0010001c001000150004001600040001000400020004" "000a0004000e000400070002000b00020004000100060001003c000100050001") PACKETS_V9 = [ "0009000c000000035c9f55980000000200000000040001e47f0000017f000001fb3c1a17fb3c19fd" "000001480000000200000000000000000035ea82110004007f0000017f000001fb3c1a17fb3c19fd" "0000007a000000020000000000000000ea820035110004007f0000017f000001fb3c1a17fb3c19fd" "000000f80000000200000000000000000035c6e2110004007f0000017f000001fb3c1a17fb3c19fd" "0000007a000000020000000000000000c6e20035110004007f0000017f000001fb3c1a9efb3c1a9c" "0000004c0000000100000000000000000035adc1110004007f0000017f000001fb3c1a9efb3c1a9c" "0000003c000000010000000000000000adc10035110004007f0000017f000001fb3c1b74fb3c1b72" "0000004c0000000100000000000000000035d0b3110004007f0000017f000001fb3c1b74fb3c1b72" "0000003c000000010000000000000000d0b30035110004007f0000017f000001fb3c2f59fb3c1b71" "00001a350000000a000000000000000000509436061b04007f0000017f000001fb3c2f59fb3c1b71" "0000038a0000000a000000000000000094360050061b04007f0000017f000001fb3c913bfb3c9138" "0000004c0000000100000000000000000035e262110004007f0000017f000001fb3c913bfb3c9138" "0000003c000000010000000000000000e262003511000400", "0009000c000000035c9f55980000000300000000040001e47f0000017f000001fb3ca523fb3c913b" "0000030700000005000000000000000000509438061b04007f0000017f000001fb3ca523fb3c913b" "000002a200000005000000000000000094380050061b04007f0000017f000001fb3f7fe1fb3dbc97" "0002d52800000097000000000000000001bb8730061b04007f0000017f000001fb3f7fe1fb3dbc97" "0000146c000000520000000000000000873001bb061f04007f0000017f000001fb3d066ffb3d066c" "0000004c0000000100000000000000000035e5bd110004007f0000017f000001fb3d066ffb3d066c" "0000003c000000010000000000000000e5bd0035110004007f0000017f000001fb3d1a61fb3d066b" "000003060000000500000000000000000050943a061b04007f0000017f000001fb3d1a61fb3d066b" "000002a2000000050000000000000000943a0050061b04007f0000017f000001fb3fed00fb3f002c" "0000344000000016000000000000000001bbae50061f04007f0000017f000001fb3fed00fb3f002c" "00000a47000000120000000000000000ae5001bb061b04007f0000017f000001fb402f17fb402a75" "0003524c000000a5000000000000000001bbc48c061b04007f0000017f000001fb402f17fb402a75" "000020a60000007e0000000000000000c48c01bb061f0400", "0009000c000000035c9f55980000000400000000040001e47f0000017f000001fb3d7ba2fb3d7ba0" "0000004c0000000100000000000000000035a399110004007f0000017f000001fb3d7ba2fb3d7ba0" "0000003c000000010000000000000000a3990035110004007f0000017f000001fb3d8f85fb3d7b9f" "000003070000000500000000000000000050943c061b04007f0000017f000001fb3d8f85fb3d7b9f" "000002a2000000050000000000000000943c0050061b04007f0000017f000001fb3d9165fb3d7f6d" "0000c97b0000002a000000000000000001bbae48061b04007f0000017f000001fb3d9165fb3d7f6d" "000007f40000001a0000000000000000ae4801bb061b04007f0000017f000001fb3dbc96fb3dbc7e" "0000011e0000000200000000000000000035bd4f110004007f0000017f000001fb3dbc96fb3dbc7e" "0000008e000000020000000000000000bd4f0035110004007f0000017f000001fb3ddbb3fb3c1a18" "0000bfee0000002f00000000000000000050ae56061b04007f0000017f000001fb3ddbb3fb3c1a18" "00000982000000270000000000000000ae560050061b04007f0000017f000001fb3ddbb3fb3c1a18" "0000130e0000001200000000000000000050e820061b04007f0000017f000001fb3ddbb3fb3c1a18" "0000059c000000140000000000000000e8200050061b0400" ] PACKET_IPFIX_TEMPLATE = "000a05202d45a4700000001300000000000200400400000e00080004000c00040016000400150004" \ "0001000400020004000a0004000e000400070002000b00020004000100060001003c000100050001" \ "000200340401000b00080004000c000400160004001500040001000400020004000a0004000e0004" \ "00200002003c000100050001000200400800000e001b0010001c0010001600040015000400010004" \ "00020004000a0004000e000400070002000b00020004000100060001003c00010005000100020034" \ "0801000b001b0010001c001000160004001500040001000400020004000a0004000e0004008b0002" \ "003c0001000500010003001e010000050001008f000400a000080131000401320004013000020100" \ "001a00000a5900000171352e672100000001000000000001040000547f000001ac110002ff7ed688" \ "ff7ed73a000015c70000000d000000000000000001bbe1a6061b0400ac1100027f000001ff7ed688" \ "ff7ed73a0000074f000000130000000000000000e1a601bb061f04000401004cac110002ac110001" \ "ff7db9e0ff7dc1d0000000fc00000003000000000000000008000400ac110001ac110002ff7db9e0" \ "ff7dc1d0000000fc0000000300000000000000000000040008010220fde66f14e0f1960900000242" \ "ac110002ff0200000000000000000001ff110001ff7dfad6ff7e0e95000001b00000000600000000" \ "0000000087000600fde66f14e0f196090000affeaffeaffefdabcdef123456789000000000000001" \ "ff7e567fff7e664a0000020800000005000000000000000080000600fde66f14e0f1960900000000" \ "00000001fde66f14e0f196090000affeaffeaffeff7e567fff7e664a000002080000000500000000" \ "0000000081000600fe800000000000000042aafffe73bbfafde66f14e0f196090000affeaffeaffe" \ "ff7e6aaaff7e6aaa0000004800000001000000000000000087000600fde66f14e0f1960900000242" \ "ac110002fe800000000000000042aafffe73bbfaff7e6aaaff7e6aaa000000400000000100000000" \ "0000000088000600fe800000000000000042acfffe110002fe800000000000000042aafffe73bbfa" \ "ff7e7eaaff7e7eaa0000004800000001000000000000000087000600fe800000000000000042aaff" \ "fe73bbfafe800000000000000042acfffe110002ff7e7eaaff7e7eaa000000400000000100000000" \ "0000000088000600fe800000000000000042aafffe73bbfafe800000000000000042acfffe110002" \ "ff7e92aaff7e92aa0000004800000001000000000000000087000600fe800000000000000042acff" \ "fe110002fe800000000000000042aafffe73bbfaff7e92aaff7e92aa000000400000000100000000" \ "000000008800060008000044fde66f14e0f196090000affeaffeaffefd41b7143f86000000000000" \ "00000001ff7ec2a0ff7ec2a00000004a000000010000000000000000d20100351100060004000054" \ "ac1100027f000001ff7ed62eff7ed68700000036000000010000000000000000c496003511000400" \ "7f000001ac110002ff7ed62eff7ed687000000760000000100000000000000000035c49611000400" \ "08000044fde66f14e0f196090000affeaffeaffefd41b7143f8600000000000000000001ff7ef359" \ "ff7ef3590000004a000000010000000000000000b1e700351100060004000054ac1100027f000001" \ "ff7f06e4ff7f06e800000036000000010000000000000000a8f90035110004007f000001ac110002" \ "ff7f06e4ff7f06e8000000a60000000100000000000000000035a8f911000400" PACKET_IPFIX = "000a00d02d45a47000000016000000000801007cfe800000000000000042acfffe110002fde66f14" \ "e0f196090000000000000001ff7f0755ff7f07550000004800000001000000000000000087000600" \ "fdabcdef123456789000000000000001fe800000000000000042acfffe110002ff7f0755ff7f0755" \ "000000400000000100000000000000008800060008000044fde66f14e0f196090000affeaffeaffe" \ "2a044e42020000000000000000000223ff7f06e9ff7f22d500000140000000040000000000000000" \ "e54c01bb06020600" PACKET_IPFIX_TEMPLATE_ETHER = "000a05002d45a4700000000d00000000" \ "000200500400001200080004000c000400160004001500040001000400020004000a0004000e0004" \ "00070002000b00020004000100060001003c000100050001003a0002003b00020038000600390006" \ "000200440401000f00080004000c000400160004001500040001000400020004000a0004000e0004" \ "00200002003c000100050001003a0002003b000200380006003900060002005008000012001b0010" \ "001c001000160004001500040001000400020004000a0004000e000400070002000b000200040001" \ "00060001003c000100050001003a0002003b00020038000600390006000200440801000f001b0010" \ "001c001000160004001500040001000400020004000a0004000e0004008b0002003c000100050001" \ "003a0002003b000200380006003900060003001e010000050001008f000400a00008013100040132" \ "0004013000020100001a00000009000000b0d80a558000000001000000000001040000747f000001" \ "ac110002e58b988be58b993e000015c70000000d000000000000000001bbe1a6061b040000000000" \ "123456affefeaffeaffeaffeac1100027f000001e58b988be58b993e0000074f0000001300000000" \ "00000000e1a601bb061f040000000000affeaffeaffe123456affefe0401006cac110002ac110001" \ "e58a7be3e58a83d3000000fc0000000300000000000000000800040000000000affeaffeaffe0242" \ "aa73bbfaac110001ac110002e58a7be3e58a83d3000000fc00000003000000000000000000000400" \ "00000000123456affefeaffeaffeaffe080102b0fde66f14e0f196090000affeaffeaffeff020000" \ "0000000000000001ff110001e58abcd9e58ad098000001b000000006000000000000000087000600" \ "00000000affeaffeaffe3333ff110001fde66f14e0f196090000affeaffeaffefde66f14e0f19609" \ "0000000000000001e58b1883e58b284e000002080000000500000000000000008000060000000000" \ "affeaffeaffe123456affefefdabcdef123456789000000000000001fde66f14e0f1960900000242" \ "ac110002e58b1883e58b284e0000020800000005000000000000000081000600000000000242aa73" \ "bbfaaffeaffeaffefe800000000000000042aafffe73bbfafde66f14e0f196090000affeaffeaffe" \ "e58b2caee58b2cae000000480000000100000000000000008700060000000000123456affefe0242" \ "ac110002fde66f14e0f196090000affeaffeaffefe800000000000000042aafffe73bbfae58b2cae" \ "e58b2cae000000400000000100000000000000008800060000000000affeaffeaffe123456affefe" \ "fe800000000000000042acfffe110002fe800000000000000042aafffe73bbfae58b40aee58b40ae" \ "000000480000000100000000000000008700060000000000affeaffeaffe123456affefefe800000" \ "000000000042aafffe73bbfafe800000000000000042acfffe110002e58b40aee58b40ae00000040" \ "0000000100000000000000008800060000000000123456affefeaffeaffeaffefe80000000000000" \ "0042aafffe73bbfafe800000000000000042acfffe110002e58b54aee58b54ae0000004800000001" \ "00000000000000008700060000000000123456affefeaffeaffeaffefe800000000000000042acff" \ "fe110002fe800000000000000042aafffe73bbfae58b54aee58b54ae000000400000000100000000" \ "000000008800060000000000affeaffeaffe123456affefe" PACKET_IPFIX_ETHER = "000a02905e8b0aa90000001600000000" \ "08000054fde66f14e0f196090000affeaffeaffefd40abcdabcd00000000000000011111e58b84a4" \ "e58b84a40000004a000000010000000000000000d20100351100060000000000affeaffeaffe0242" \ "aa73bbfa04000074ac1100027f000001e58b9831e58b988a00000036000000010000000000000000" \ "c49600351100040000000000affeaffeaffe123456affefe7f000001ac110002e58b9831e58b988a" \ "000000760000000100000000000000000035c4961100040000000000123456affefeaffeaffeaffe" \ "08000054fde66f14e0f196090000affeaffeaffefd40abcdabcd00000000000000011111e58bb55c" \ "e58bb55c0000004a000000010000000000000000b1e700351100060000000000affeaffeaffe0242" \ "aa73bbfa04000074ac1100027f000001e58bc8e8e58bc8ec00000036000000010000000000000000" \ "a8f900351100040000000000affeaffeaffe123456affefe7f000001ac110002e58bc8e8e58bc8ec" \ "000000a60000000100000000000000000035a8f91100040000000000123456affefeaffeaffeaffe" \ "0801009cfe800000000000000042acfffe110002fdabcdef123456789000000000000001e58bc958" \ "e58bc958000000480000000100000000000000008700060000000000affeaffeaffe123456affefe" \ "fdabcdef123456789000000000000001fe800000000000000042acfffe110002e58bc958e58bc958" \ "000000400000000100000000000000008800060000000000123456affefeaffeaffeaffe08000054" \ "fde66f14e0f196090000affeaffeaffe2a044e42020000000000000000000223e58bc8ede58be4d8" \ "00000140000000040000000000000000e54c01bb0602060000000000affeaffeaffe123456affefe"

true

f71347c3a5a7c73ebffb636b8ab864f7bc6703ed

30,444

py

Python

toolz/functoolz.py

twoertwein/toolz

4171cf00dae791cf3ec7d66ac49d59d3df7c1ea2

[ "BSD-3-Clause" ]

null

toolz/functoolz.py

twoertwein/toolz

4171cf00dae791cf3ec7d66ac49d59d3df7c1ea2

[ "BSD-3-Clause" ]

null

toolz/functoolz.py

twoertwein/toolz

4171cf00dae791cf3ec7d66ac49d59d3df7c1ea2

[ "BSD-3-Clause" ]

null

from __future__ import annotations import inspect import sys from functools import partial, reduce from importlib import import_module from operator import attrgetter, not_ from textwrap import dedent from types import MethodType from typing import Any, Callable, Dict, Generic, TypeVar, Union, overload from .utils import no_default __all__ = ('identity', 'apply', 'thread_first', 'thread_last', 'memoize', 'compose', 'compose_left', 'pipe', 'complement', 'juxt', 'do', 'curry', 'flip', 'excepts') PYPY = hasattr(sys, 'pypy_version_info') _T = TypeVar("_T") _T2 = TypeVar("_T2") def identity(x: _T) ->_T: """ Identity function. Return x >>> identity(3) 3 """ return x def apply(*func_and_args, **kwargs): """ Applies a function and returns the results >>> def double(x): return 2*x >>> def inc(x): return x + 1 >>> apply(double, 5) 10 >>> tuple(map(apply, [double, inc, double], [10, 500, 8000])) (20, 501, 16000) """ if not func_and_args: raise TypeError('func argument is required') func, args = func_and_args[0], func_and_args[1:] return func(*args, **kwargs) def thread_first(val, *forms): """ Thread value through a sequence of functions/forms >>> def double(x): return 2*x >>> def inc(x): return x + 1 >>> thread_first(1, inc, double) 4 If the function expects more than one input you can specify those inputs in a tuple. The value is used as the first input. >>> def add(x, y): return x + y >>> def pow(x, y): return x**y >>> thread_first(1, (add, 4), (pow, 2)) # pow(add(1, 4), 2) 25 So in general thread_first(x, f, (g, y, z)) expands to g(f(x), y, z) See Also: thread_last """ def evalform_front(val, form): if callable(form): return form(val) if isinstance(form, tuple): func, args = form[0], form[1:] args = (val,) + args return func(*args) return reduce(evalform_front, forms, val) def thread_last(val, *forms): """ Thread value through a sequence of functions/forms >>> def double(x): return 2*x >>> def inc(x): return x + 1 >>> thread_last(1, inc, double) 4 If the function expects more than one input you can specify those inputs in a tuple. The value is used as the last input. >>> def add(x, y): return x + y >>> def pow(x, y): return x**y >>> thread_last(1, (add, 4), (pow, 2)) # pow(2, add(4, 1)) 32 So in general thread_last(x, f, (g, y, z)) expands to g(y, z, f(x)) >>> def iseven(x): ... return x % 2 == 0 >>> list(thread_last([1, 2, 3], (map, inc), (filter, iseven))) [2, 4] See Also: thread_first """ def evalform_back(val, form): if callable(form): return form(val) if isinstance(form, tuple): func, args = form[0], form[1:] args = args + (val,) return func(*args) return reduce(evalform_back, forms, val) def instanceproperty(fget=None, fset=None, fdel=None, doc=None, classval=None): """ Like @property, but returns ``classval`` when used as a class attribute >>> class MyClass(object): ... '''The class docstring''' ... @instanceproperty(classval=__doc__) ... def __doc__(self): ... return 'An object docstring' ... @instanceproperty ... def val(self): ... return 42 ... >>> MyClass.__doc__ 'The class docstring' >>> MyClass.val is None True >>> obj = MyClass() >>> obj.__doc__ 'An object docstring' >>> obj.val 42 """ if fget is None: return partial(instanceproperty, fset=fset, fdel=fdel, doc=doc, classval=classval) return InstanceProperty(fget=fget, fset=fset, fdel=fdel, doc=doc, classval=classval) class InstanceProperty(property): """ Like @property, but returns ``classval`` when used as a class attribute Should not be used directly. Use ``instanceproperty`` instead. """ def __init__(self, fget=None, fset=None, fdel=None, doc=None, classval=None): self.classval = classval property.__init__(self, fget=fget, fset=fset, fdel=fdel, doc=doc) def __get__(self, obj, type=None): if obj is None: return self.classval return property.__get__(self, obj, type) def __reduce__(self): state = (self.fget, self.fset, self.fdel, self.__doc__, self.classval) return InstanceProperty, state class curry(Generic[_T]): """ Curry a callable function Enables partial application of arguments through calling a function with an incomplete set of arguments. >>> def mul(x, y): ... return x * y >>> mul = curry(mul) >>> double = mul(2) >>> double(10) 20 Also supports keyword arguments >>> @curry # Can use curry as a decorator ... def f(x, y, a=10): ... return a * (x + y) >>> add = f(a=1) >>> add(2, 3) 5 See Also: toolz.curried - namespace of curried functions https://toolz.readthedocs.io/en/latest/curry.html """ @overload def __init__(self, func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ... # this overload should never be used, mypy complains if only one overload exists @overload def __init__(self, *args: Union[Callable[..., _T], Any], **kwargs: Any) -> None: ... def __init__(self, *args: Any, **kwargs: Any) -> None: if not args: raise TypeError('__init__() takes at least 2 arguments (1 given)') func, args = args[0], args[1:] if not callable(func): raise TypeError("Input must be callable") # curry- or functools.partial-like object? Unpack and merge arguments if ( hasattr(func, 'func') and hasattr(func, 'args') and hasattr(func, 'keywords') and isinstance(func.args, tuple) ): _kwargs = {} if func.keywords: _kwargs.update(func.keywords) _kwargs.update(kwargs) kwargs = _kwargs args = func.args + args func = func.func if kwargs: self._partial = partial(func, *args, **kwargs) else: self._partial = partial(func, *args) self.__doc__ = getattr(func, '__doc__', None) self.__name__ = getattr(func, '__name__', '<curry>') self.__module__ = getattr(func, '__module__', None) self.__qualname__ = getattr(func, '__qualname__', None) self._sigspec = None self._has_unknown_args = None @instanceproperty def func(self) -> Callable[..., _T]: return self._partial.func @instanceproperty def __signature__(self): sig = inspect.signature(self.func) args = self.args or () keywords = self.keywords or {} if is_partial_args(self.func, args, keywords, sig) is False: raise TypeError('curry object has incorrect arguments') params = list(sig.parameters.values()) skip = 0 for param in params[:len(args)]: if param.kind == param.VAR_POSITIONAL: break skip += 1 kwonly = False newparams = [] for param in params[skip:]: kind = param.kind default = param.default if kind == param.VAR_KEYWORD: pass elif kind == param.VAR_POSITIONAL: if kwonly: continue elif param.name in keywords: default = keywords[param.name] kind = param.KEYWORD_ONLY kwonly = True else: if kwonly: kind = param.KEYWORD_ONLY if default is param.empty: default = no_default newparams.append(param.replace(default=default, kind=kind)) return sig.replace(parameters=newparams) @instanceproperty def args(self): return self._partial.args @instanceproperty def keywords(self) -> Dict[str, Any]: return self._partial.keywords @instanceproperty def func_name(self) -> str: return self.__name__ def __str__(self) -> str: return str(self.func) def __repr__(self) -> str: return repr(self.func) def __hash__(self) -> int: return hash((self.func, self.args, frozenset(self.keywords.items()) if self.keywords else None)) def __eq__(self, other: Any) -> bool: return (isinstance(other, curry) and self.func == other.func and self.args == other.args and self.keywords == other.keywords) def __ne__(self, other: Any) -> bool: return not self.__eq__(other) def __call__(self, *args: Any, **kwargs: Any) -> Union[_T, curry[_T]]: try: return self._partial(*args, **kwargs) except TypeError as exc: if self._should_curry(args, kwargs, exc): return self.bind(*args, **kwargs) raise def _should_curry(self, args, kwargs, exc=None): func = self.func args = self.args + args if self.keywords: kwargs = dict(self.keywords, **kwargs) if self._sigspec is None: sigspec = self._sigspec = _sigs.signature_or_spec(func) self._has_unknown_args = has_varargs(func, sigspec) is not False else: sigspec = self._sigspec if is_partial_args(func, args, kwargs, sigspec) is False: # Nothing can make the call valid return False elif self._has_unknown_args: # The call may be valid and raised a TypeError, but we curry # anyway because the function may have `*args`. This is useful # for decorators with signature `func(*args, **kwargs)`. return True elif not is_valid_args(func, args, kwargs, sigspec): # Adding more arguments may make the call valid return True else: # There was a genuine TypeError return False def bind(self, *args, **kwargs) -> curry[_T]: return type(self)(self, *args, **kwargs) def call(self, *args, **kwargs) -> _T: return self._partial(*args, **kwargs) def __get__(self, instance, owner): if instance is None: return self return curry(self, instance) def __reduce__(self): func = self.func modname = getattr(func, '__module__', None) qualname = getattr(func, '__qualname__', None) if qualname is None: # pragma: no cover qualname = getattr(func, '__name__', None) is_decorated = None if modname and qualname: attrs = [] obj = import_module(modname) for attr in qualname.split('.'): if isinstance(obj, curry): attrs.append('func') obj = obj.func obj = getattr(obj, attr, None) if obj is None: break attrs.append(attr) if isinstance(obj, curry) and obj.func is func: is_decorated = obj is self qualname = '.'.join(attrs) func = '%s:%s' % (modname, qualname) # functools.partial objects can't be pickled userdict = tuple((k, v) for k, v in self.__dict__.items() if k not in ('_partial', '_sigspec')) state = (type(self), func, self.args, self.keywords, userdict, is_decorated) return _restore_curry, state def _restore_curry(cls, func, args, kwargs, userdict, is_decorated): if isinstance(func, str): modname, qualname = func.rsplit(':', 1) obj = import_module(modname) for attr in qualname.split('.'): obj = getattr(obj, attr) if is_decorated: return obj func = obj.func obj = cls(func, *args, **(kwargs or {})) obj.__dict__.update(userdict) return obj @curry def memoize(func, cache=None, key=None): """ Cache a function's result for speedy future evaluation Considerations: Trades memory for speed. Only use on pure functions. >>> def add(x, y): return x + y >>> add = memoize(add) Or use as a decorator >>> @memoize ... def add(x, y): ... return x + y Use the ``cache`` keyword to provide a dict-like object as an initial cache >>> @memoize(cache={(1, 2): 3}) ... def add(x, y): ... return x + y Note that the above works as a decorator because ``memoize`` is curried. It is also possible to provide a ``key(args, kwargs)`` function that calculates keys used for the cache, which receives an ``args`` tuple and ``kwargs`` dict as input, and must return a hashable value. However, the default key function should be sufficient most of the time. >>> # Use key function that ignores extraneous keyword arguments >>> @memoize(key=lambda args, kwargs: args) ... def add(x, y, verbose=False): ... if verbose: ... print('Calculating %s + %s' % (x, y)) ... return x + y """ if cache is None: cache = {} try: may_have_kwargs = has_keywords(func) is not False # Is unary function (single arg, no variadic argument or keywords)? is_unary = is_arity(1, func) except TypeError: # pragma: no cover may_have_kwargs = True is_unary = False if key is None: if is_unary: def key(args, kwargs): return args[0] elif may_have_kwargs: def key(args, kwargs): return ( args or None, frozenset(kwargs.items()) if kwargs else None, ) else: def key(args, kwargs): return args def memof(*args, **kwargs): k = key(args, kwargs) try: return cache[k] except TypeError: raise TypeError("Arguments to memoized function must be hashable") except KeyError: cache[k] = result = func(*args, **kwargs) return result try: memof.__name__ = func.__name__ except AttributeError: pass memof.__doc__ = func.__doc__ memof.__wrapped__ = func return memof class Compose(object): """ A composition of functions See Also: compose """ __slots__ = 'first', 'funcs' def __init__(self, funcs): funcs = tuple(reversed(funcs)) self.first = funcs[0] self.funcs = funcs[1:] def __call__(self, *args, **kwargs): ret = self.first(*args, **kwargs) for f in self.funcs: ret = f(ret) return ret def __getstate__(self): return self.first, self.funcs def __setstate__(self, state): self.first, self.funcs = state @instanceproperty(classval=__doc__) def __doc__(self): def composed_doc(*fs): """Generate a docstring for the composition of fs. """ if not fs: # Argument name for the docstring. return '*args, **kwargs' return '{f}({g})'.format(f=fs[0].__name__, g=composed_doc(*fs[1:])) try: return ( 'lambda *args, **kwargs: ' + composed_doc(*reversed((self.first,) + self.funcs)) ) except AttributeError: # One of our callables does not have a `__name__`, whatever. return 'A composition of functions' @property def __name__(self): try: return '_of_'.join( (f.__name__ for f in reversed((self.first,) + self.funcs)) ) except AttributeError: return type(self).__name__ def __repr__(self): return '{.__class__.__name__}{!r}'.format( self, tuple(reversed((self.first, ) + self.funcs))) def __eq__(self, other): if isinstance(other, Compose): return other.first == self.first and other.funcs == self.funcs return NotImplemented def __ne__(self, other): equality = self.__eq__(other) return NotImplemented if equality is NotImplemented else not equality def __hash__(self): return hash(self.first) ^ hash(self.funcs) # Mimic the descriptor behavior of python functions. # i.e. let Compose be called as a method when bound to a class. # adapted from # docs.python.org/3/howto/descriptor.html#functions-and-methods def __get__(self, obj, objtype=None): return self if obj is None else MethodType(self, obj) # introspection with Signature is only possible from py3.3+ @instanceproperty def __signature__(self): base = inspect.signature(self.first) last = inspect.signature(self.funcs[-1]) return base.replace(return_annotation=last.return_annotation) __wrapped__ = instanceproperty(attrgetter('first')) def compose(*funcs): """ Compose functions to operate in series. Returns a function that applies other functions in sequence. Functions are applied from right to left so that ``compose(f, g, h)(x, y)`` is the same as ``f(g(h(x, y)))``. If no arguments are provided, the identity function (f(x) = x) is returned. >>> inc = lambda i: i + 1 >>> compose(str, inc)(3) '4' See Also: compose_left pipe """ if not funcs: return identity if len(funcs) == 1: return funcs[0] else: return Compose(funcs) def compose_left(*funcs): """ Compose functions to operate in series. Returns a function that applies other functions in sequence. Functions are applied from left to right so that ``compose_left(f, g, h)(x, y)`` is the same as ``h(g(f(x, y)))``. If no arguments are provided, the identity function (f(x) = x) is returned. >>> inc = lambda i: i + 1 >>> compose_left(inc, str)(3) '4' See Also: compose pipe """ return compose(*reversed(funcs)) def pipe(data, *funcs): """ Pipe a value through a sequence of functions I.e. ``pipe(data, f, g, h)`` is equivalent to ``h(g(f(data)))`` We think of the value as progressing through a pipe of several transformations, much like pipes in UNIX ``$ cat data | f | g | h`` >>> double = lambda i: 2 * i >>> pipe(3, double, str) '6' See Also: compose compose_left thread_first thread_last """ for func in funcs: data = func(data) return data def complement(func): """ Convert a predicate function to its logical complement. In other words, return a function that, for inputs that normally yield True, yields False, and vice-versa. >>> def iseven(n): return n % 2 == 0 >>> isodd = complement(iseven) >>> iseven(2) True >>> isodd(2) False """ return compose(not_, func) class juxt(object): """ Creates a function that calls several functions with the same arguments Takes several functions and returns a function that applies its arguments to each of those functions then returns a tuple of the results. Name comes from juxtaposition: the fact of two things being seen or placed close together with contrasting effect. >>> inc = lambda x: x + 1 >>> double = lambda x: x * 2 >>> juxt(inc, double)(10) (11, 20) >>> juxt([inc, double])(10) (11, 20) """ __slots__ = ['funcs'] def __init__(self, *funcs): if len(funcs) == 1 and not callable(funcs[0]): funcs = funcs[0] self.funcs = tuple(funcs) def __call__(self, *args, **kwargs): return tuple(func(*args, **kwargs) for func in self.funcs) def __getstate__(self): return self.funcs def __setstate__(self, state): self.funcs = state def do(func: Callable[[_T], Any], x: _T) -> _T: """ Runs ``func`` on ``x``, returns ``x`` Because the results of ``func`` are not returned, only the side effects of ``func`` are relevant. Logging functions can be made by composing ``do`` with a storage function like ``list.append`` or ``file.write`` >>> from toolz import compose >>> from toolz.curried import do >>> log = [] >>> inc = lambda x: x + 1 >>> inc = compose(inc, do(log.append)) >>> inc(1) 2 >>> inc(11) 12 >>> log [1, 11] """ func(x) return x @curry def flip(func: Callable[[_T, _T], _T2], a: _T, b: _T) -> _T2: """ Call the function call with the arguments flipped This function is curried. >>> def div(a, b): ... return a // b ... >>> flip(div, 2, 6) 3 >>> div_by_two = flip(div, 2) >>> div_by_two(4) 2 This is particularly useful for built in functions and functions defined in C extensions that accept positional only arguments. For example: isinstance, issubclass. >>> data = [1, 'a', 'b', 2, 1.5, object(), 3] >>> only_ints = list(filter(flip(isinstance, int), data)) >>> only_ints [1, 2, 3] """ return func(b, a) def return_none(exc: Any) -> None: """ Returns None. """ return None class excepts(object): """A wrapper around a function to catch exceptions and dispatch to a handler. This is like a functional try/except block, in the same way that ifexprs are functional if/else blocks. Examples -------- >>> excepting = excepts( ... ValueError, ... lambda a: [1, 2].index(a), ... lambda _: -1, ... ) >>> excepting(1) 0 >>> excepting(3) -1 Multiple exceptions and default except clause. >>> excepting = excepts((IndexError, KeyError), lambda a: a[0]) >>> excepting([]) >>> excepting([1]) 1 >>> excepting({}) >>> excepting({0: 1}) 1 """ def __init__(self, exc, func, handler=return_none): self.exc = exc self.func = func self.handler = handler def __call__(self, *args, **kwargs): try: return self.func(*args, **kwargs) except self.exc as e: return self.handler(e) @instanceproperty(classval=__doc__) def __doc__(self): exc = self.exc try: if isinstance(exc, tuple): exc_name = '(%s)' % ', '.join( map(attrgetter('__name__'), exc), ) else: exc_name = exc.__name__ return dedent( """\ A wrapper around {inst.func.__name__!r} that will except: {exc} and handle any exceptions with {inst.handler.__name__!r}. Docs for {inst.func.__name__!r}: {inst.func.__doc__} Docs for {inst.handler.__name__!r}: {inst.handler.__doc__} """ ).format( inst=self, exc=exc_name, ) except AttributeError: return type(self).__doc__ @property def __name__(self): exc = self.exc try: if isinstance(exc, tuple): exc_name = '_or_'.join(map(attrgetter('__name__'), exc)) else: exc_name = exc.__name__ return '%s_excepting_%s' % (self.func.__name__, exc_name) except AttributeError: return 'excepting' def _check_sigspec(sigspec, func, builtin_func, *builtin_args): if sigspec is None: try: sigspec = inspect.signature(func) except (ValueError, TypeError) as e: sigspec = e if isinstance(sigspec, ValueError): return None, builtin_func(*builtin_args) elif not isinstance(sigspec, inspect.Signature): if ( func in _sigs.signatures and (( hasattr(func, '__signature__') and hasattr(func.__signature__, '__get__') )) ): val = builtin_func(*builtin_args) return None, val return None, False return sigspec, None if PYPY: # pragma: no cover _check_sigspec_orig = _check_sigspec def _check_sigspec(sigspec, func, builtin_func, *builtin_args): # PyPy may lie, so use our registry for builtins instead if func in _sigs.signatures: val = builtin_func(*builtin_args) return None, val return _check_sigspec_orig(sigspec, func, builtin_func, *builtin_args) _check_sigspec.__doc__ = """ \ Private function to aid in introspection compatibly across Python versions. If a callable doesn't have a signature (Python 3) or an argspec (Python 2), the signature registry in toolz._signatures is used. """ def num_required_args(func, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._num_required_args, func) if sigspec is None: return rv return sum(1 for p in sigspec.parameters.values() if p.default is p.empty and p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY)) def has_varargs(func, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._has_varargs, func) if sigspec is None: return rv return any(p.kind == p.VAR_POSITIONAL for p in sigspec.parameters.values()) def has_keywords(func, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._has_keywords, func) if sigspec is None: return rv return any(p.default is not p.empty or p.kind in (p.KEYWORD_ONLY, p.VAR_KEYWORD) for p in sigspec.parameters.values()) def is_valid_args(func, args, kwargs, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._is_valid_args, func, args, kwargs) if sigspec is None: return rv try: sigspec.bind(*args, **kwargs) except TypeError: return False return True def is_partial_args(func, args, kwargs, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._is_partial_args, func, args, kwargs) if sigspec is None: return rv try: sigspec.bind_partial(*args, **kwargs) except TypeError: return False return True def is_arity(n, func, sigspec=None): """ Does a function have only n positional arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x): ... return x >>> is_arity(1, f) True >>> def g(x, y=1): ... return x + y >>> is_arity(1, g) False """ sigspec, rv = _check_sigspec(sigspec, func, _sigs._is_arity, n, func) if sigspec is None: return rv num = num_required_args(func, sigspec) if num is not None: num = num == n if not num: return False varargs = has_varargs(func, sigspec) if varargs: return False keywords = has_keywords(func, sigspec) if keywords: return False if num is None or varargs is None or keywords is None: # pragma: no cover return None return True num_required_args.__doc__ = """ \ Number of required positional arguments This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x, y, z=3): ... return x + y + z >>> num_required_args(f) 2 >>> def g(*args, **kwargs): ... pass >>> num_required_args(g) 0 """ has_varargs.__doc__ = """ \ Does a function have variadic positional arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(*args): ... return args >>> has_varargs(f) True >>> def g(**kwargs): ... return kwargs >>> has_varargs(g) False """ has_keywords.__doc__ = """ \ Does a function have keyword arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x, y=0): ... return x + y >>> has_keywords(f) True """ is_valid_args.__doc__ = """ \ Is ``func(*args, **kwargs)`` a valid function call? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def add(x, y): ... return x + y >>> is_valid_args(add, (1,), {}) False >>> is_valid_args(add, (1, 2), {}) True >>> is_valid_args(map, (), {}) False **Implementation notes** Python 2 relies on ``inspect.getargspec``, which only works for user-defined functions. Python 3 uses ``inspect.signature``, which works for many more types of callables. Many builtins in the standard library are also supported. """ is_partial_args.__doc__ = """ \ Can partial(func, *args, **kwargs)(*args2, **kwargs2) be a valid call? Returns True *only* if the call is valid or if it is possible for the call to become valid by adding more positional or keyword arguments. This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def add(x, y): ... return x + y >>> is_partial_args(add, (1,), {}) True >>> is_partial_args(add, (1, 2), {}) True >>> is_partial_args(add, (1, 2, 3), {}) False >>> is_partial_args(map, (), {}) True **Implementation notes** Python 2 relies on ``inspect.getargspec``, which only works for user-defined functions. Python 3 uses ``inspect.signature``, which works for many more types of callables. Many builtins in the standard library are also supported. """ from . import _signatures as _sigs

28.802271

88

0.577914

from __future__ import annotations import inspect import sys from functools import partial, reduce from importlib import import_module from operator import attrgetter, not_ from textwrap import dedent from types import MethodType from typing import Any, Callable, Dict, Generic, TypeVar, Union, overload from .utils import no_default __all__ = ('identity', 'apply', 'thread_first', 'thread_last', 'memoize', 'compose', 'compose_left', 'pipe', 'complement', 'juxt', 'do', 'curry', 'flip', 'excepts') PYPY = hasattr(sys, 'pypy_version_info') _T = TypeVar("_T") _T2 = TypeVar("_T2") def identity(x: _T) ->_T: return x def apply(*func_and_args, **kwargs): if not func_and_args: raise TypeError('func argument is required') func, args = func_and_args[0], func_and_args[1:] return func(*args, **kwargs) def thread_first(val, *forms): def evalform_front(val, form): if callable(form): return form(val) if isinstance(form, tuple): func, args = form[0], form[1:] args = (val,) + args return func(*args) return reduce(evalform_front, forms, val) def thread_last(val, *forms): def evalform_back(val, form): if callable(form): return form(val) if isinstance(form, tuple): func, args = form[0], form[1:] args = args + (val,) return func(*args) return reduce(evalform_back, forms, val) def instanceproperty(fget=None, fset=None, fdel=None, doc=None, classval=None): if fget is None: return partial(instanceproperty, fset=fset, fdel=fdel, doc=doc, classval=classval) return InstanceProperty(fget=fget, fset=fset, fdel=fdel, doc=doc, classval=classval) class InstanceProperty(property): def __init__(self, fget=None, fset=None, fdel=None, doc=None, classval=None): self.classval = classval property.__init__(self, fget=fget, fset=fset, fdel=fdel, doc=doc) def __get__(self, obj, type=None): if obj is None: return self.classval return property.__get__(self, obj, type) def __reduce__(self): state = (self.fget, self.fset, self.fdel, self.__doc__, self.classval) return InstanceProperty, state class curry(Generic[_T]): @overload def __init__(self, func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ... @overload def __init__(self, *args: Union[Callable[..., _T], Any], **kwargs: Any) -> None: ... def __init__(self, *args: Any, **kwargs: Any) -> None: if not args: raise TypeError('__init__() takes at least 2 arguments (1 given)') func, args = args[0], args[1:] if not callable(func): raise TypeError("Input must be callable") if ( hasattr(func, 'func') and hasattr(func, 'args') and hasattr(func, 'keywords') and isinstance(func.args, tuple) ): _kwargs = {} if func.keywords: _kwargs.update(func.keywords) _kwargs.update(kwargs) kwargs = _kwargs args = func.args + args func = func.func if kwargs: self._partial = partial(func, *args, **kwargs) else: self._partial = partial(func, *args) self.__doc__ = getattr(func, '__doc__', None) self.__name__ = getattr(func, '__name__', '<curry>') self.__module__ = getattr(func, '__module__', None) self.__qualname__ = getattr(func, '__qualname__', None) self._sigspec = None self._has_unknown_args = None @instanceproperty def func(self) -> Callable[..., _T]: return self._partial.func @instanceproperty def __signature__(self): sig = inspect.signature(self.func) args = self.args or () keywords = self.keywords or {} if is_partial_args(self.func, args, keywords, sig) is False: raise TypeError('curry object has incorrect arguments') params = list(sig.parameters.values()) skip = 0 for param in params[:len(args)]: if param.kind == param.VAR_POSITIONAL: break skip += 1 kwonly = False newparams = [] for param in params[skip:]: kind = param.kind default = param.default if kind == param.VAR_KEYWORD: pass elif kind == param.VAR_POSITIONAL: if kwonly: continue elif param.name in keywords: default = keywords[param.name] kind = param.KEYWORD_ONLY kwonly = True else: if kwonly: kind = param.KEYWORD_ONLY if default is param.empty: default = no_default newparams.append(param.replace(default=default, kind=kind)) return sig.replace(parameters=newparams) @instanceproperty def args(self): return self._partial.args @instanceproperty def keywords(self) -> Dict[str, Any]: return self._partial.keywords @instanceproperty def func_name(self) -> str: return self.__name__ def __str__(self) -> str: return str(self.func) def __repr__(self) -> str: return repr(self.func) def __hash__(self) -> int: return hash((self.func, self.args, frozenset(self.keywords.items()) if self.keywords else None)) def __eq__(self, other: Any) -> bool: return (isinstance(other, curry) and self.func == other.func and self.args == other.args and self.keywords == other.keywords) def __ne__(self, other: Any) -> bool: return not self.__eq__(other) def __call__(self, *args: Any, **kwargs: Any) -> Union[_T, curry[_T]]: try: return self._partial(*args, **kwargs) except TypeError as exc: if self._should_curry(args, kwargs, exc): return self.bind(*args, **kwargs) raise def _should_curry(self, args, kwargs, exc=None): func = self.func args = self.args + args if self.keywords: kwargs = dict(self.keywords, **kwargs) if self._sigspec is None: sigspec = self._sigspec = _sigs.signature_or_spec(func) self._has_unknown_args = has_varargs(func, sigspec) is not False else: sigspec = self._sigspec if is_partial_args(func, args, kwargs, sigspec) is False: return False elif self._has_unknown_args: return True elif not is_valid_args(func, args, kwargs, sigspec): return True else: return False def bind(self, *args, **kwargs) -> curry[_T]: return type(self)(self, *args, **kwargs) def call(self, *args, **kwargs) -> _T: return self._partial(*args, **kwargs) def __get__(self, instance, owner): if instance is None: return self return curry(self, instance) def __reduce__(self): func = self.func modname = getattr(func, '__module__', None) qualname = getattr(func, '__qualname__', None) if qualname is None: qualname = getattr(func, '__name__', None) is_decorated = None if modname and qualname: attrs = [] obj = import_module(modname) for attr in qualname.split('.'): if isinstance(obj, curry): attrs.append('func') obj = obj.func obj = getattr(obj, attr, None) if obj is None: break attrs.append(attr) if isinstance(obj, curry) and obj.func is func: is_decorated = obj is self qualname = '.'.join(attrs) func = '%s:%s' % (modname, qualname) userdict = tuple((k, v) for k, v in self.__dict__.items() if k not in ('_partial', '_sigspec')) state = (type(self), func, self.args, self.keywords, userdict, is_decorated) return _restore_curry, state def _restore_curry(cls, func, args, kwargs, userdict, is_decorated): if isinstance(func, str): modname, qualname = func.rsplit(':', 1) obj = import_module(modname) for attr in qualname.split('.'): obj = getattr(obj, attr) if is_decorated: return obj func = obj.func obj = cls(func, *args, **(kwargs or {})) obj.__dict__.update(userdict) return obj @curry def memoize(func, cache=None, key=None): if cache is None: cache = {} try: may_have_kwargs = has_keywords(func) is not False # Is unary function (single arg, no variadic argument or keywords)? is_unary = is_arity(1, func) except TypeError: # pragma: no cover may_have_kwargs = True is_unary = False if key is None: if is_unary: def key(args, kwargs): return args[0] elif may_have_kwargs: def key(args, kwargs): return ( args or None, frozenset(kwargs.items()) if kwargs else None, ) else: def key(args, kwargs): return args def memof(*args, **kwargs): k = key(args, kwargs) try: return cache[k] except TypeError: raise TypeError("Arguments to memoized function must be hashable") except KeyError: cache[k] = result = func(*args, **kwargs) return result try: memof.__name__ = func.__name__ except AttributeError: pass memof.__doc__ = func.__doc__ memof.__wrapped__ = func return memof class Compose(object): __slots__ = 'first', 'funcs' def __init__(self, funcs): funcs = tuple(reversed(funcs)) self.first = funcs[0] self.funcs = funcs[1:] def __call__(self, *args, **kwargs): ret = self.first(*args, **kwargs) for f in self.funcs: ret = f(ret) return ret def __getstate__(self): return self.first, self.funcs def __setstate__(self, state): self.first, self.funcs = state @instanceproperty(classval=__doc__) def __doc__(self): def composed_doc(*fs): if not fs: # Argument name for the docstring. return '*args, **kwargs' return '{f}({g})'.format(f=fs[0].__name__, g=composed_doc(*fs[1:])) try: return ( 'lambda *args, **kwargs: ' + composed_doc(*reversed((self.first,) + self.funcs)) ) except AttributeError: # One of our callables does not have a `__name__`, whatever. return 'A composition of functions' @property def __name__(self): try: return '_of_'.join( (f.__name__ for f in reversed((self.first,) + self.funcs)) ) except AttributeError: return type(self).__name__ def __repr__(self): return '{.__class__.__name__}{!r}'.format( self, tuple(reversed((self.first, ) + self.funcs))) def __eq__(self, other): if isinstance(other, Compose): return other.first == self.first and other.funcs == self.funcs return NotImplemented def __ne__(self, other): equality = self.__eq__(other) return NotImplemented if equality is NotImplemented else not equality def __hash__(self): return hash(self.first) ^ hash(self.funcs) # Mimic the descriptor behavior of python functions. # i.e. let Compose be called as a method when bound to a class. # adapted from # docs.python.org/3/howto/descriptor.html#functions-and-methods def __get__(self, obj, objtype=None): return self if obj is None else MethodType(self, obj) # introspection with Signature is only possible from py3.3+ @instanceproperty def __signature__(self): base = inspect.signature(self.first) last = inspect.signature(self.funcs[-1]) return base.replace(return_annotation=last.return_annotation) __wrapped__ = instanceproperty(attrgetter('first')) def compose(*funcs): if not funcs: return identity if len(funcs) == 1: return funcs[0] else: return Compose(funcs) def compose_left(*funcs): return compose(*reversed(funcs)) def pipe(data, *funcs): for func in funcs: data = func(data) return data def complement(func): return compose(not_, func) class juxt(object): __slots__ = ['funcs'] def __init__(self, *funcs): if len(funcs) == 1 and not callable(funcs[0]): funcs = funcs[0] self.funcs = tuple(funcs) def __call__(self, *args, **kwargs): return tuple(func(*args, **kwargs) for func in self.funcs) def __getstate__(self): return self.funcs def __setstate__(self, state): self.funcs = state def do(func: Callable[[_T], Any], x: _T) -> _T: func(x) return x @curry def flip(func: Callable[[_T, _T], _T2], a: _T, b: _T) -> _T2: return func(b, a) def return_none(exc: Any) -> None: return None class excepts(object): def __init__(self, exc, func, handler=return_none): self.exc = exc self.func = func self.handler = handler def __call__(self, *args, **kwargs): try: return self.func(*args, **kwargs) except self.exc as e: return self.handler(e) @instanceproperty(classval=__doc__) def __doc__(self): exc = self.exc try: if isinstance(exc, tuple): exc_name = '(%s)' % ', '.join( map(attrgetter('__name__'), exc), ) else: exc_name = exc.__name__ return dedent( """\ A wrapper around {inst.func.__name__!r} that will except: {exc} and handle any exceptions with {inst.handler.__name__!r}. Docs for {inst.func.__name__!r}: {inst.func.__doc__} Docs for {inst.handler.__name__!r}: {inst.handler.__doc__} """ ).format( inst=self, exc=exc_name, ) except AttributeError: return type(self).__doc__ @property def __name__(self): exc = self.exc try: if isinstance(exc, tuple): exc_name = '_or_'.join(map(attrgetter('__name__'), exc)) else: exc_name = exc.__name__ return '%s_excepting_%s' % (self.func.__name__, exc_name) except AttributeError: return 'excepting' def _check_sigspec(sigspec, func, builtin_func, *builtin_args): if sigspec is None: try: sigspec = inspect.signature(func) except (ValueError, TypeError) as e: sigspec = e if isinstance(sigspec, ValueError): return None, builtin_func(*builtin_args) elif not isinstance(sigspec, inspect.Signature): if ( func in _sigs.signatures and (( hasattr(func, '__signature__') and hasattr(func.__signature__, '__get__') )) ): val = builtin_func(*builtin_args) return None, val return None, False return sigspec, None if PYPY: # pragma: no cover _check_sigspec_orig = _check_sigspec def _check_sigspec(sigspec, func, builtin_func, *builtin_args): # PyPy may lie, so use our registry for builtins instead if func in _sigs.signatures: val = builtin_func(*builtin_args) return None, val return _check_sigspec_orig(sigspec, func, builtin_func, *builtin_args) _check_sigspec.__doc__ = """ \ Private function to aid in introspection compatibly across Python versions. If a callable doesn't have a signature (Python 3) or an argspec (Python 2), the signature registry in toolz._signatures is used. """ def num_required_args(func, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._num_required_args, func) if sigspec is None: return rv return sum(1 for p in sigspec.parameters.values() if p.default is p.empty and p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY)) def has_varargs(func, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._has_varargs, func) if sigspec is None: return rv return any(p.kind == p.VAR_POSITIONAL for p in sigspec.parameters.values()) def has_keywords(func, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._has_keywords, func) if sigspec is None: return rv return any(p.default is not p.empty or p.kind in (p.KEYWORD_ONLY, p.VAR_KEYWORD) for p in sigspec.parameters.values()) def is_valid_args(func, args, kwargs, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._is_valid_args, func, args, kwargs) if sigspec is None: return rv try: sigspec.bind(*args, **kwargs) except TypeError: return False return True def is_partial_args(func, args, kwargs, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._is_partial_args, func, args, kwargs) if sigspec is None: return rv try: sigspec.bind_partial(*args, **kwargs) except TypeError: return False return True def is_arity(n, func, sigspec=None): sigspec, rv = _check_sigspec(sigspec, func, _sigs._is_arity, n, func) if sigspec is None: return rv num = num_required_args(func, sigspec) if num is not None: num = num == n if not num: return False varargs = has_varargs(func, sigspec) if varargs: return False keywords = has_keywords(func, sigspec) if keywords: return False if num is None or varargs is None or keywords is None: return None return True num_required_args.__doc__ = """ \ Number of required positional arguments This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x, y, z=3): ... return x + y + z >>> num_required_args(f) 2 >>> def g(*args, **kwargs): ... pass >>> num_required_args(g) 0 """ has_varargs.__doc__ = """ \ Does a function have variadic positional arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(*args): ... return args >>> has_varargs(f) True >>> def g(**kwargs): ... return kwargs >>> has_varargs(g) False """ has_keywords.__doc__ = """ \ Does a function have keyword arguments? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def f(x, y=0): ... return x + y >>> has_keywords(f) True """ is_valid_args.__doc__ = """ \ Is ``func(*args, **kwargs)`` a valid function call? This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def add(x, y): ... return x + y >>> is_valid_args(add, (1,), {}) False >>> is_valid_args(add, (1, 2), {}) True >>> is_valid_args(map, (), {}) False **Implementation notes** Python 2 relies on ``inspect.getargspec``, which only works for user-defined functions. Python 3 uses ``inspect.signature``, which works for many more types of callables. Many builtins in the standard library are also supported. """ is_partial_args.__doc__ = """ \ Can partial(func, *args, **kwargs)(*args2, **kwargs2) be a valid call? Returns True *only* if the call is valid or if it is possible for the call to become valid by adding more positional or keyword arguments. This function relies on introspection and does not call the function. Returns None if validity can't be determined. >>> def add(x, y): ... return x + y >>> is_partial_args(add, (1,), {}) True >>> is_partial_args(add, (1, 2), {}) True >>> is_partial_args(add, (1, 2, 3), {}) False >>> is_partial_args(map, (), {}) True **Implementation notes** Python 2 relies on ``inspect.getargspec``, which only works for user-defined functions. Python 3 uses ``inspect.signature``, which works for many more types of callables. Many builtins in the standard library are also supported. """ from . import _signatures as _sigs

true

f71347fe2477679277a83c7c8d547eb46223cf1f

6,757

py

Python

tests/gpu/test_torch.py

AkashNarayanan/pennylane

b855176ebd5c84a49f51babce0a6d5af1ef29142

[ "Apache-2.0" ]

null

tests/gpu/test_torch.py

AkashNarayanan/pennylane

b855176ebd5c84a49f51babce0a6d5af1ef29142

[ "Apache-2.0" ]

1

2021-12-09T22:04:41.000Z

2022-01-19T14:21:03.000Z

tests/gpu/test_torch.py

AkashNarayanan/pennylane

b855176ebd5c84a49f51babce0a6d5af1ef29142

[ "Apache-2.0" ]

null

# Copyright 2018-2021 Xanadu Quantum Technologies Inc. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import pytest import pennylane as qml from pennylane import numpy as np pytestmark = pytest.mark.gpu torch = pytest.importorskip("torch") @pytest.mark.skipif(not torch.cuda.is_available(), reason="no cuda support") class TestTorchDevice: def test_device_to_cuda(self): """Checks device executes with cuda is input data is cuda""" dev = qml.device("default.qubit.torch", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) with qml.tape.QuantumTape() as tape: qml.RX(x, wires=0) qml.expval(qml.PauliX(0)) res = dev.execute(tape) assert res.is_cuda assert dev._torch_device == "cuda" res.backward() assert x.grad.is_cuda def test_mixed_devices(self): """Asserts works with both cuda and cpu input data""" dev = qml.device("default.qubit.torch", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) y = torch.tensor(0.2, requires_grad=True, device=torch.device("cpu")) with qml.tape.QuantumTape() as tape: qml.RX(x, wires=0) qml.RY(y, wires=0) qml.expval(qml.PauliX(0)) res = dev.execute(tape) assert res.is_cuda assert dev._torch_device == "cuda" res.backward() assert x.grad.is_cuda # check that this works ygrad = y.grad def test_matrix_input(self): """Test goes to GPU for matrix valued inputs.""" dev = qml.device("default.qubit.torch", wires=1) U = torch.eye(2, requires_grad=False, device=torch.device("cuda")) with qml.tape.QuantumTape() as tape: qml.QubitUnitary(U, wires=0) qml.expval(qml.PauliZ(0)) res = dev.execute(tape) assert res.is_cuda assert dev._torch_device == "cuda" def test_resets(self): """Asserts reverts to cpu after execution on gpu""" dev = qml.device("default.qubit.torch", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) y = torch.tensor(0.2, requires_grad=True, device=torch.device("cpu")) with qml.tape.QuantumTape() as tape1: qml.RX(x, wires=0) qml.expval(qml.PauliZ(0)) res1 = dev.execute(tape1) assert dev._torch_device == "cuda" assert res1.is_cuda with qml.tape.QuantumTape() as tape2: qml.RY(y, wires=0) qml.expval(qml.PauliZ(0)) res2 = dev.execute(tape2) assert dev._torch_device == "cpu" assert not res2.is_cuda def test_integration(self): """Test cuda supported when device created in qnode creation.""" dev = qml.device("default.qubit", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) y = torch.tensor(0.2, requires_grad=True) @qml.qnode(dev, interface="torch", diff_method="backprop") def circ(x, y): qml.RX(x, wires=0) qml.RY(y, wires=0) return qml.expval(qml.PauliZ(0)) res = circ(x, y) assert res.is_cuda assert circ.device._torch_device == "cuda" res.backward() assert x.grad.is_cuda @pytest.mark.parametrize("init_device, par_device", [("cpu", "cuda"), ("cuda", "cpu")]) def test_different_devices_creation_and_parameters_warn(self, init_device, par_device): """Test that a warning is raised if the Torch device specified on PennyLane device creation differs from the Torch device of gate parameters. """ dev = qml.device("default.qubit.torch", wires=1, torch_device=init_device) p = torch.tensor(0.543, dtype=torch.float64, device=par_device) @qml.qnode(dev, interface="torch") def circuit(x): qml.RX(x, wires=0) return qml.expval(qml.PauliY(0)) with pytest.warns( UserWarning, match=f"Torch device {init_device} specified upon PennyLane device creation does not match", ): circuit(p) @pytest.mark.skipif(not torch.cuda.is_available(), reason="no cuda support") class TestqnnTorchLayer: def test_torch_device_cuda_if_tensors_on_cuda(self): """Test that if any tensor passed to operators is on the GPU then CUDA is set internally as a device option for 'default.qubit.torch'.""" n_qubits = 3 n_layers = 1 dev = qml.device("default.qubit", wires=n_qubits) @qml.qnode(dev) def circuit(inputs, weights): qml.templates.AngleEmbedding(inputs, wires=range(n_qubits)) qml.templates.BasicEntanglerLayers(weights, wires=range(n_qubits)) return [qml.expval(qml.PauliZ(wires=i)) for i in range(n_qubits)] weight_shapes = {"weights": (n_layers, n_qubits)} qlayer = qml.qnn.TorchLayer(circuit, weight_shapes) x = torch.rand((5, n_qubits), dtype=torch.float64).to(torch.device("cuda")) res = qlayer(x) assert circuit.device.short_name == "default.qubit.torch" assert circuit.device._torch_device == "cuda" assert res.is_cuda loss = torch.sum(res).squeeze() loss.backward() assert loss.is_cuda def test_qnn_torchlayer(self): """Test if TorchLayer can be run on GPU""" n_qubits = 4 dev = qml.device("default.qubit", wires=n_qubits) @qml.qnode(dev, interface="torch") def circuit(inputs, weights): qml.templates.AngleEmbedding(inputs, wires=range(n_qubits)) qml.templates.BasicEntanglerLayers(weights, wires=range(n_qubits)) return [qml.expval(qml.PauliZ(wires=i)) for i in range(n_qubits)] n_layers = 1 weight_shapes = {"weights": (n_layers, n_qubits)} qlayer = qml.qnn.TorchLayer(circuit, weight_shapes) x = torch.rand((5, n_qubits), dtype=torch.float64).to(torch.device("cuda")) res = qlayer(x) assert res.is_cuda loss = torch.sum(res).squeeze() loss.backward() assert loss.is_cuda

33.122549

104

0.630309

import pytest import pennylane as qml from pennylane import numpy as np pytestmark = pytest.mark.gpu torch = pytest.importorskip("torch") @pytest.mark.skipif(not torch.cuda.is_available(), reason="no cuda support") class TestTorchDevice: def test_device_to_cuda(self): dev = qml.device("default.qubit.torch", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) with qml.tape.QuantumTape() as tape: qml.RX(x, wires=0) qml.expval(qml.PauliX(0)) res = dev.execute(tape) assert res.is_cuda assert dev._torch_device == "cuda" res.backward() assert x.grad.is_cuda def test_mixed_devices(self): dev = qml.device("default.qubit.torch", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) y = torch.tensor(0.2, requires_grad=True, device=torch.device("cpu")) with qml.tape.QuantumTape() as tape: qml.RX(x, wires=0) qml.RY(y, wires=0) qml.expval(qml.PauliX(0)) res = dev.execute(tape) assert res.is_cuda assert dev._torch_device == "cuda" res.backward() assert x.grad.is_cuda ygrad = y.grad def test_matrix_input(self): dev = qml.device("default.qubit.torch", wires=1) U = torch.eye(2, requires_grad=False, device=torch.device("cuda")) with qml.tape.QuantumTape() as tape: qml.QubitUnitary(U, wires=0) qml.expval(qml.PauliZ(0)) res = dev.execute(tape) assert res.is_cuda assert dev._torch_device == "cuda" def test_resets(self): dev = qml.device("default.qubit.torch", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) y = torch.tensor(0.2, requires_grad=True, device=torch.device("cpu")) with qml.tape.QuantumTape() as tape1: qml.RX(x, wires=0) qml.expval(qml.PauliZ(0)) res1 = dev.execute(tape1) assert dev._torch_device == "cuda" assert res1.is_cuda with qml.tape.QuantumTape() as tape2: qml.RY(y, wires=0) qml.expval(qml.PauliZ(0)) res2 = dev.execute(tape2) assert dev._torch_device == "cpu" assert not res2.is_cuda def test_integration(self): dev = qml.device("default.qubit", wires=1) x = torch.tensor(0.1, requires_grad=True, device=torch.device("cuda")) y = torch.tensor(0.2, requires_grad=True) @qml.qnode(dev, interface="torch", diff_method="backprop") def circ(x, y): qml.RX(x, wires=0) qml.RY(y, wires=0) return qml.expval(qml.PauliZ(0)) res = circ(x, y) assert res.is_cuda assert circ.device._torch_device == "cuda" res.backward() assert x.grad.is_cuda @pytest.mark.parametrize("init_device, par_device", [("cpu", "cuda"), ("cuda", "cpu")]) def test_different_devices_creation_and_parameters_warn(self, init_device, par_device): dev = qml.device("default.qubit.torch", wires=1, torch_device=init_device) p = torch.tensor(0.543, dtype=torch.float64, device=par_device) @qml.qnode(dev, interface="torch") def circuit(x): qml.RX(x, wires=0) return qml.expval(qml.PauliY(0)) with pytest.warns( UserWarning, match=f"Torch device {init_device} specified upon PennyLane device creation does not match", ): circuit(p) @pytest.mark.skipif(not torch.cuda.is_available(), reason="no cuda support") class TestqnnTorchLayer: def test_torch_device_cuda_if_tensors_on_cuda(self): n_qubits = 3 n_layers = 1 dev = qml.device("default.qubit", wires=n_qubits) @qml.qnode(dev) def circuit(inputs, weights): qml.templates.AngleEmbedding(inputs, wires=range(n_qubits)) qml.templates.BasicEntanglerLayers(weights, wires=range(n_qubits)) return [qml.expval(qml.PauliZ(wires=i)) for i in range(n_qubits)] weight_shapes = {"weights": (n_layers, n_qubits)} qlayer = qml.qnn.TorchLayer(circuit, weight_shapes) x = torch.rand((5, n_qubits), dtype=torch.float64).to(torch.device("cuda")) res = qlayer(x) assert circuit.device.short_name == "default.qubit.torch" assert circuit.device._torch_device == "cuda" assert res.is_cuda loss = torch.sum(res).squeeze() loss.backward() assert loss.is_cuda def test_qnn_torchlayer(self): n_qubits = 4 dev = qml.device("default.qubit", wires=n_qubits) @qml.qnode(dev, interface="torch") def circuit(inputs, weights): qml.templates.AngleEmbedding(inputs, wires=range(n_qubits)) qml.templates.BasicEntanglerLayers(weights, wires=range(n_qubits)) return [qml.expval(qml.PauliZ(wires=i)) for i in range(n_qubits)] n_layers = 1 weight_shapes = {"weights": (n_layers, n_qubits)} qlayer = qml.qnn.TorchLayer(circuit, weight_shapes) x = torch.rand((5, n_qubits), dtype=torch.float64).to(torch.device("cuda")) res = qlayer(x) assert res.is_cuda loss = torch.sum(res).squeeze() loss.backward() assert loss.is_cuda

true

f71348bd486f0c866016007c0288d43d9925e4e2

531

py

Python

RecoVertex/BeamSpotProducer/python/BeamSpotOnline_cfi.py

malbouis/cmssw

16173a30d3f0c9ecc5419c474bb4d272c58b65c8

[ "Apache-2.0" ]

852

2015-01-11T21:03:51.000Z

2022-03-25T21:14:00.000Z

RecoVertex/BeamSpotProducer/python/BeamSpotOnline_cfi.py

malbouis/cmssw

16173a30d3f0c9ecc5419c474bb4d272c58b65c8

[ "Apache-2.0" ]

30,371

2015-01-02T00:14:40.000Z

2022-03-31T23:26:05.000Z

RecoVertex/BeamSpotProducer/python/BeamSpotOnline_cfi.py

malbouis/cmssw

16173a30d3f0c9ecc5419c474bb4d272c58b65c8

[ "Apache-2.0" ]

3,240

2015-01-02T05:53:18.000Z

2022-03-31T17:24:21.000Z

import FWCore.ParameterSet.Config as cms import RecoVertex.BeamSpotProducer.beamSpotOnlineProducer_cfi as _mod onlineBeamSpotProducer = _mod.beamSpotOnlineProducer.clone( src = 'scalersRawToDigi', setSigmaZ = -1, #negative value disables it. gtEvmLabel = 'gtEvmDigis' ) from Configuration.Eras.Modifier_run3_common_cff import run3_common run3_common.toModify(onlineBeamSpotProducer, useTransientRecord = True)

48.272727

84

0.65725

import FWCore.ParameterSet.Config as cms import RecoVertex.BeamSpotProducer.beamSpotOnlineProducer_cfi as _mod onlineBeamSpotProducer = _mod.beamSpotOnlineProducer.clone( src = 'scalersRawToDigi', setSigmaZ = -1, gtEvmLabel = 'gtEvmDigis' ) from Configuration.Eras.Modifier_run3_common_cff import run3_common run3_common.toModify(onlineBeamSpotProducer, useTransientRecord = True)

true

f71349190ba9885865b0ec68a6c3596e268f4125

4,096

py

Python

sib_api_v3_sdk/models/get_blocked_domains.py

alemangui/APIv3-python-library

129dbee603ed91d756fdec3670c8f95be86cdd2c

[ "MIT" ]

46

2018-12-18T21:37:18.000Z

2022-03-30T20:38:29.000Z

sib_api_v3_sdk/models/get_blocked_domains.py

alemangui/APIv3-python-library

129dbee603ed91d756fdec3670c8f95be86cdd2c

[ "MIT" ]

41

2018-03-02T13:22:48.000Z

2021-11-25T04:32:03.000Z

sib_api_v3_sdk/models/get_blocked_domains.py

alemangui/APIv3-python-library

129dbee603ed91d756fdec3670c8f95be86cdd2c

[ "MIT" ]

45

2018-01-22T14:42:32.000Z

2021-12-16T19:58:45.000Z

# coding: utf-8 """ SendinBlue API SendinBlue provide a RESTFul API that can be used with any languages. With this API, you will be able to : - Manage your campaigns and get the statistics - Manage your contacts - Send transactional Emails and SMS - and much more... You can download our wrappers at https://github.com/orgs/sendinblue **Possible responses** | Code | Message | | :-------------: | ------------- | | 200 | OK. Successful Request | | 201 | OK. Successful Creation | | 202 | OK. Request accepted | | 204 | OK. Successful Update/Deletion | | 400 | Error. Bad Request | | 401 | Error. Authentication Needed | | 402 | Error. Not enough credit, plan upgrade needed | | 403 | Error. Permission denied | | 404 | Error. Object does not exist | | 405 | Error. Method not allowed | | 406 | Error. Not Acceptable | # noqa: E501 OpenAPI spec version: 3.0.0 Contact: contact@sendinblue.com Generated by: https://github.com/swagger-api/swagger-codegen.git """ import pprint import re # noqa: F401 import six class GetBlockedDomains(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. """ """ Attributes: swagger_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ swagger_types = { 'domains': 'list[str]' } attribute_map = { 'domains': 'domains' } def __init__(self, domains=None): # noqa: E501 """GetBlockedDomains - a model defined in Swagger""" # noqa: E501 self._domains = None self.discriminator = None self.domains = domains @property def domains(self): """Gets the domains of this GetBlockedDomains. # noqa: E501 List of all blocked domains # noqa: E501 :return: The domains of this GetBlockedDomains. # noqa: E501 :rtype: list[str] """ return self._domains @domains.setter def domains(self, domains): """Sets the domains of this GetBlockedDomains. List of all blocked domains # noqa: E501 :param domains: The domains of this GetBlockedDomains. # noqa: E501 :type: list[str] """ if domains is None: raise ValueError("Invalid value for `domains`, must not be `None`") # noqa: E501 self._domains = domains def to_dict(self): """Returns the model properties as a dict""" result = {} for attr, _ in six.iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value if issubclass(GetBlockedDomains, dict): for key, value in self.items(): result[key] = value return result def to_str(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self): """For `print` and `pprint`""" return self.to_str() def __eq__(self, other): """Returns true if both objects are equal""" if not isinstance(other, GetBlockedDomains): return False return self.__dict__ == other.__dict__ def __ne__(self, other): """Returns true if both objects are not equal""" return not self == other

34.420168

856

0.575684

import pprint import re import six class GetBlockedDomains(object): swagger_types = { 'domains': 'list[str]' } attribute_map = { 'domains': 'domains' } def __init__(self, domains=None): self._domains = None self.discriminator = None self.domains = domains @property def domains(self): return self._domains @domains.setter def domains(self, domains): if domains is None: raise ValueError("Invalid value for `domains`, must not be `None`") self._domains = domains def to_dict(self): result = {} for attr, _ in six.iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value if issubclass(GetBlockedDomains, dict): for key, value in self.items(): result[key] = value return result def to_str(self): return pprint.pformat(self.to_dict()) def __repr__(self): return self.to_str() def __eq__(self, other): if not isinstance(other, GetBlockedDomains): return False return self.__dict__ == other.__dict__ def __ne__(self, other): return not self == other

true

f71349271ce549389e3aebe169cebe8b443a80be

5,567

py

Python

modules/SenseHatDisplay/app/DisplayManager.py

fiddi/Custom-vision-service-iot-edge-raspberry-pi

f0f0a0d2155692fc4caaa613e79d3ab30fc7dbf4

[ "MIT" ]

null

modules/SenseHatDisplay/app/DisplayManager.py

fiddi/Custom-vision-service-iot-edge-raspberry-pi

f0f0a0d2155692fc4caaa613e79d3ab30fc7dbf4

[ "MIT" ]

null

modules/SenseHatDisplay/app/DisplayManager.py

fiddi/Custom-vision-service-iot-edge-raspberry-pi

f0f0a0d2155692fc4caaa613e79d3ab30fc7dbf4

[ "MIT" ]

null

import sense_hat from sense_hat import SenseHat import time from enum import Enum class Colors(Enum): Green = (0, 255, 0) Yellow = (255, 255, 0) Blue = (0, 0, 255) Red = (255, 0, 0) White = (255,255,255) Nothing = (0,0,0) Pink = (255,105, 180) Orange = (255,165, 0) class DisplayManager(object): def __raspberry(self): G = Colors.Green.value N = Colors.Nothing.value R = Colors.Red.value logo = [ N, G, G, N, N, G, G, N, N, N, G, G, G, G, N, N, N, N, R, R, R, R, N, N, N, R, R, R, R, R, R, N, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, N, R, R, R, R, R, R, N, N, N, R, R, R, R, N, N, ] return logo def __lego(self): W = Colors.White.value R = Colors.Red.value Y = Colors.Yellow.value logo = [ R, Y, Y, Y, Y, R, R, R, R, Y, W, W, Y, R, R, R, R, Y, W, W, Y, R, R, R, R, Y, W, W, Y, R, R, R, R, Y, W, W, Y, Y, Y, R, R, Y, W, W, W, W, Y, R, R, Y, W, W, W, W, Y, R, R, Y, Y, Y, Y, Y, Y, R, ] return logo def __figure(self): N = Colors.Nothing.value Y = Colors.Yellow.value B = Colors.Blue.value R = Colors.Red.value logo = [ N, N, N, N, N, N, N, N, N, N, Y, Y, Y, Y, N, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, B, Y, Y, B, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, R, Y, Y, R, Y, N, N, N, Y, R, R, Y, N, N, N, N, N, Y, Y, N, N, N, ] return logo def __red4x2(self): N = Colors.Nothing.value Y = Colors.Red.value logo = [ N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, Y, N, Y, N, Y, N, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __yellow4x2(self): N = Colors.Nothing.value Y = Colors.Yellow.value logo = [ N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, Y, N, Y, N, Y, N, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __blue4x2(self): N = Colors.Nothing.value Y = Colors.Blue.value logo = [ N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, Y, N, Y, N, Y, N, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __red2x2(self): N = Colors.Nothing.value Y = Colors.Red.value logo = [ N, N, N, N, N, N, N, N, N, Y, Y, N, N, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __yellow2x2(self): N = Colors.Nothing.value Y = Colors.Yellow.value logo = [ N, N, N, N, N, N, N, N, N, Y, Y, N, N, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __blue2x2(self): N = Colors.Nothing.value Y = Colors.Blue.value logo = [ N, N, N, N, N, N, N, N, N, Y, Y, N, N, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __unknown(self): N = Colors.Nothing.value R = Colors.Red.value logo = [ N, N, N, R, R, N, N, N, N, N, R, N, N, R, N, N, N, R, N, N, N, N, R, N, N, R, N, N, N, N, R, N, N, N, R, N, N, R, N, N, N, N, N, N, R, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, R, N, N, N, ] return logo def __init__(self): self.s = SenseHat() self.s.low_light = True self.__displayImage(self.__raspberry())#Flash the raspberry pi logo at initialization time.sleep(1) self.s.clear() def __displayImage(self, image): self.s.set_pixels(image) def displayImage(self, strImage): print("Displaying " + strImage) if 'yellow-4x2' in strImage.lower(): self.__displayImage(self.__yellow4x2()) elif 'yellow-2x2' in strImage.lower(): self.__displayImage(self.__yellow2x2()) elif 'red-4x2' in strImage.lower(): self.__displayImage(self.__red4x2()) elif 'red-2x2' in strImage.lower(): self.__displayImage(self.__red2x2()) elif 'blue-4x2' in strImage.lower(): self.__displayImage(self.__blue4x2()) elif 'blue-2x2' in strImage.lower(): self.__displayImage(self.__blue2x2()) elif 'figure' in strImage.lower(): self.__displayImage(self.__figure()) elif 'none' in strImage.lower(): self.__displayImage(self.__lego()) else: self.__displayImage(self.__lego())

27.835

93

0.40794

import sense_hat from sense_hat import SenseHat import time from enum import Enum class Colors(Enum): Green = (0, 255, 0) Yellow = (255, 255, 0) Blue = (0, 0, 255) Red = (255, 0, 0) White = (255,255,255) Nothing = (0,0,0) Pink = (255,105, 180) Orange = (255,165, 0) class DisplayManager(object): def __raspberry(self): G = Colors.Green.value N = Colors.Nothing.value R = Colors.Red.value logo = [ N, G, G, N, N, G, G, N, N, N, G, G, G, G, N, N, N, N, R, R, R, R, N, N, N, R, R, R, R, R, R, N, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, R, N, R, R, R, R, R, R, N, N, N, R, R, R, R, N, N, ] return logo def __lego(self): W = Colors.White.value R = Colors.Red.value Y = Colors.Yellow.value logo = [ R, Y, Y, Y, Y, R, R, R, R, Y, W, W, Y, R, R, R, R, Y, W, W, Y, R, R, R, R, Y, W, W, Y, R, R, R, R, Y, W, W, Y, Y, Y, R, R, Y, W, W, W, W, Y, R, R, Y, W, W, W, W, Y, R, R, Y, Y, Y, Y, Y, Y, R, ] return logo def __figure(self): N = Colors.Nothing.value Y = Colors.Yellow.value B = Colors.Blue.value R = Colors.Red.value logo = [ N, N, N, N, N, N, N, N, N, N, Y, Y, Y, Y, N, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, B, Y, Y, B, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, R, Y, Y, R, Y, N, N, N, Y, R, R, Y, N, N, N, N, N, Y, Y, N, N, N, ] return logo def __red4x2(self): N = Colors.Nothing.value Y = Colors.Red.value logo = [ N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, Y, N, Y, N, Y, N, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __yellow4x2(self): N = Colors.Nothing.value Y = Colors.Yellow.value logo = [ N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, Y, N, Y, N, Y, N, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __blue4x2(self): N = Colors.Nothing.value Y = Colors.Blue.value logo = [ N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, Y, N, Y, N, Y, N, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, Y, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __red2x2(self): N = Colors.Nothing.value Y = Colors.Red.value logo = [ N, N, N, N, N, N, N, N, N, Y, Y, N, N, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __yellow2x2(self): N = Colors.Nothing.value Y = Colors.Yellow.value logo = [ N, N, N, N, N, N, N, N, N, Y, Y, N, N, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __blue2x2(self): N = Colors.Nothing.value Y = Colors.Blue.value logo = [ N, N, N, N, N, N, N, N, N, Y, Y, N, N, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, Y, Y, Y, Y, Y, Y, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, ] return logo def __unknown(self): N = Colors.Nothing.value R = Colors.Red.value logo = [ N, N, N, R, R, N, N, N, N, N, R, N, N, R, N, N, N, R, N, N, N, N, R, N, N, R, N, N, N, N, R, N, N, N, R, N, N, R, N, N, N, N, N, N, R, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, R, N, N, N, ] return logo def __init__(self): self.s = SenseHat() self.s.low_light = True self.__displayImage(self.__raspberry()) time.sleep(1) self.s.clear() def __displayImage(self, image): self.s.set_pixels(image) def displayImage(self, strImage): print("Displaying " + strImage) if 'yellow-4x2' in strImage.lower(): self.__displayImage(self.__yellow4x2()) elif 'yellow-2x2' in strImage.lower(): self.__displayImage(self.__yellow2x2()) elif 'red-4x2' in strImage.lower(): self.__displayImage(self.__red4x2()) elif 'red-2x2' in strImage.lower(): self.__displayImage(self.__red2x2()) elif 'blue-4x2' in strImage.lower(): self.__displayImage(self.__blue4x2()) elif 'blue-2x2' in strImage.lower(): self.__displayImage(self.__blue2x2()) elif 'figure' in strImage.lower(): self.__displayImage(self.__figure()) elif 'none' in strImage.lower(): self.__displayImage(self.__lego()) else: self.__displayImage(self.__lego())

true

f7134a2cdb66d523656539ca32e9257e50702023

1,706

py

Python

test/python/test_15_fds.py

macneib/Discovery-Server

c499531422e671527f8676e3efba30015993b5d3

[ "Apache-2.0" ]

null

test/python/test_15_fds.py

macneib/Discovery-Server

c499531422e671527f8676e3efba30015993b5d3

[ "Apache-2.0" ]

null

test/python/test_15_fds.py

macneib/Discovery-Server

c499531422e671527f8676e3efba30015993b5d3

[ "Apache-2.0" ]

1

2021-06-02T11:16:26.000Z

# Copyright 2020 Proyectos y Sistemas de Mantenimiento SL (eProsima). # # 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 subprocess, time, os, sys # compose the arguments fastserver_path = sys.argv[1] # '\\...\\discovery-server\\build64\\Debug\\fast-discovery-serverd-1.0.0' server_listening_port = sys.argv[2] # CMake generated random port discovery_path = sys.argv[3] # '\\...\\discovery-server\\build64\\Debug\\discovery-server-1.1.0d.exe' xml_config_path = sys.argv[4] # '\\...\\discovery-server\\build64\\Debug\\test_15_fds.xml' # print(f'arguments: {fastserver_path} {server_listening_port} {discovery_path} {xml_config_path}') # launch server and clients server = subprocess.Popen([fastserver_path, '-i', '5', '-l', '127.0.0.1', '-p', f'{server_listening_port}']) clients = subprocess.Popen([discovery_path, xml_config_path]) # wait till clients test is finished, then kill the server clients.communicate() server.kill() if clients.returncode: # 0 if everything goes fine, validation passed print(f'discovery-server process fault on clients: returncode {clients.returncode}', file=sys.stderr) sys.exit(clients.returncode) # success sys.exit(0)

43.74359

113

0.732122

import subprocess, time, os, sys fastserver_path = sys.argv[1] server_listening_port = sys.argv[2] discovery_path = sys.argv[3] xml_config_path = sys.argv[4] server = subprocess.Popen([fastserver_path, '-i', '5', '-l', '127.0.0.1', '-p', f'{server_listening_port}']) clients = subprocess.Popen([discovery_path, xml_config_path]) clients.communicate() server.kill() if clients.returncode: print(f'discovery-server process fault on clients: returncode {clients.returncode}', file=sys.stderr) sys.exit(clients.returncode) sys.exit(0)

true

f7134b472b92121c2bb201a0a0fb36b28bf8499b

33,495

py

Python

methods.py

Vedurumudi-Priyanka/godot

17d588f7b3acf292daeae88dd3d95fa2f6240349

[ "CC-BY-3.0", "Apache-2.0", "MIT" ]

1

2021-06-04T14:29:54.000Z

methods.py

1502shivam-singh/godot

4a4be06260085d7aad8c7082d6d59a14fcc279e8

[ "CC-BY-3.0", "Apache-2.0", "MIT" ]

6

2020-10-05T20:00:21.000Z

2021-07-10T19:07:27.000Z

methods.py

1502shivam-singh/godot

4a4be06260085d7aad8c7082d6d59a14fcc279e8

[ "CC-BY-3.0", "Apache-2.0", "MIT" ]

2

2020-12-28T13:10:08.000Z

2021-12-31T20:53:18.000Z

import os import re import glob import subprocess from collections import OrderedDict # We need to define our own `Action` method to control the verbosity of output # and whenever we need to run those commands in a subprocess on some platforms. from SCons.Script import Action from SCons import Node from SCons.Script import Glob from platform_methods import run_in_subprocess def add_source_files(self, sources, files, warn_duplicates=True): # Convert string to list of absolute paths (including expanding wildcard) if isinstance(files, (str, bytes)): # Keep SCons project-absolute path as they are (no wildcard support) if files.startswith("#"): if "*" in files: print("ERROR: Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files)) return files = [files] else: dir_path = self.Dir(".").abspath files = sorted(glob.glob(dir_path + "/" + files)) # Add each path as compiled Object following environment (self) configuration for path in files: obj = self.Object(path) if obj in sources: if warn_duplicates: print('WARNING: Object "{}" already included in environment sources.'.format(obj)) else: continue sources.append(obj) def disable_warnings(self): # 'self' is the environment if self.msvc: # We have to remove existing warning level defines before appending /w, # otherwise we get: "warning D9025 : overriding '/W3' with '/w'" warn_flags = ["/Wall", "/W4", "/W3", "/W2", "/W1", "/WX"] self.Append(CCFLAGS=["/w"]) self.Append(CFLAGS=["/w"]) self.Append(CXXFLAGS=["/w"]) self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x in warn_flags] self["CFLAGS"] = [x for x in self["CFLAGS"] if not x in warn_flags] self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x in warn_flags] else: self.Append(CCFLAGS=["-w"]) self.Append(CFLAGS=["-w"]) self.Append(CXXFLAGS=["-w"]) def add_module_version_string(self, s): self.module_version_string += "." + s def update_version(module_version_string=""): build_name = "custom_build" if os.getenv("BUILD_NAME") != None: build_name = os.getenv("BUILD_NAME") print("Using custom build name: " + build_name) import version # NOTE: It is safe to generate this file here, since this is still executed serially f = open("core/version_generated.gen.h", "w") f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n") f.write("#ifndef VERSION_GENERATED_GEN_H\n") f.write("#define VERSION_GENERATED_GEN_H\n") f.write('#define VERSION_SHORT_NAME "' + str(version.short_name) + '"\n') f.write('#define VERSION_NAME "' + str(version.name) + '"\n') f.write("#define VERSION_MAJOR " + str(version.major) + "\n") f.write("#define VERSION_MINOR " + str(version.minor) + "\n") f.write("#define VERSION_PATCH " + str(version.patch) + "\n") f.write('#define VERSION_STATUS "' + str(version.status) + '"\n') f.write('#define VERSION_BUILD "' + str(build_name) + '"\n') f.write('#define VERSION_MODULE_CONFIG "' + str(version.module_config) + module_version_string + '"\n') f.write("#define VERSION_YEAR " + str(version.year) + "\n") f.write('#define VERSION_WEBSITE "' + str(version.website) + '"\n') f.write("#endif // VERSION_GENERATED_GEN_H\n") f.close() # NOTE: It is safe to generate this file here, since this is still executed serially fhash = open("core/version_hash.gen.h", "w") fhash.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n") fhash.write("#ifndef VERSION_HASH_GEN_H\n") fhash.write("#define VERSION_HASH_GEN_H\n") githash = "" gitfolder = ".git" if os.path.isfile(".git"): module_folder = open(".git", "r").readline().strip() if module_folder.startswith("gitdir: "): gitfolder = module_folder[8:] if os.path.isfile(os.path.join(gitfolder, "HEAD")): head = open(os.path.join(gitfolder, "HEAD"), "r", encoding="utf8").readline().strip() if head.startswith("ref: "): head = os.path.join(gitfolder, head[5:]) if os.path.isfile(head): githash = open(head, "r").readline().strip() else: githash = head fhash.write('#define VERSION_HASH "' + githash + '"\n') fhash.write("#endif // VERSION_HASH_GEN_H\n") fhash.close() def parse_cg_file(fname, uniforms, sizes, conditionals): fs = open(fname, "r") line = fs.readline() while line: if re.match(r"^\s*uniform", line): res = re.match(r"uniform ([\d\w]*) ([\d\w]*)") type = res.groups(1) name = res.groups(2) uniforms.append(name) if type.find("texobj") != -1: sizes.append(1) else: t = re.match(r"float(\d)x(\d)", type) if t: sizes.append(int(t.groups(1)) * int(t.groups(2))) else: t = re.match(r"float(\d)", type) sizes.append(int(t.groups(1))) if line.find("[branch]") != -1: conditionals.append(name) line = fs.readline() fs.close() def detect_modules(at_path): module_list = OrderedDict() # name : path modules_glob = os.path.join(at_path, "*") files = glob.glob(modules_glob) files.sort() # so register_module_types does not change that often, and also plugins are registered in alphabetic order for x in files: if not is_module(x): continue name = os.path.basename(x) path = x.replace("\\", "/") # win32 module_list[name] = path return module_list def is_module(path): return os.path.isdir(path) and os.path.exists(os.path.join(path, "SCsub")) def write_modules(module_list): includes_cpp = "" preregister_cpp = "" register_cpp = "" unregister_cpp = "" for name, path in module_list.items(): try: with open(os.path.join(path, "register_types.h")): includes_cpp += '#include "' + path + '/register_types.h"\n' preregister_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n" preregister_cpp += "#ifdef MODULE_" + name.upper() + "_HAS_PREREGISTER\n" preregister_cpp += "\tpreregister_" + name + "_types();\n" preregister_cpp += "#endif\n" preregister_cpp += "#endif\n" register_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n" register_cpp += "\tregister_" + name + "_types();\n" register_cpp += "#endif\n" unregister_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n" unregister_cpp += "\tunregister_" + name + "_types();\n" unregister_cpp += "#endif\n" except OSError: pass modules_cpp = """// register_module_types.gen.cpp /* THIS FILE IS GENERATED DO NOT EDIT */ #include "register_module_types.h" #include "modules/modules_enabled.gen.h" %s void preregister_module_types() { %s } void register_module_types() { %s } void unregister_module_types() { %s } """ % ( includes_cpp, preregister_cpp, register_cpp, unregister_cpp, ) # NOTE: It is safe to generate this file here, since this is still executed serially with open("modules/register_module_types.gen.cpp", "w") as f: f.write(modules_cpp) def convert_custom_modules_path(path): if not path: return path path = os.path.realpath(os.path.expanduser(os.path.expandvars(path))) err_msg = "Build option 'custom_modules' must %s" if not os.path.isdir(path): raise ValueError(err_msg % "point to an existing directory.") if path == os.path.realpath("modules"): raise ValueError(err_msg % "be a directory other than built-in `modules` directory.") if is_module(path): raise ValueError(err_msg % "point to a directory with modules, not a single module.") return path def disable_module(self): self.disabled_modules.append(self.current_module) def module_check_dependencies(self, module, dependencies): """ Checks if module dependencies are enabled for a given module, and prints a warning if they aren't. Meant to be used in module `can_build` methods. Returns a boolean (True if dependencies are satisfied). """ missing_deps = [] for dep in dependencies: opt = "module_{}_enabled".format(dep) if not opt in self or not self[opt]: missing_deps.append(dep) if missing_deps != []: print( "Disabling '{}' module as the following dependencies are not satisfied: {}".format( module, ", ".join(missing_deps) ) ) return False else: return True def use_windows_spawn_fix(self, platform=None): if os.name != "nt": return # not needed, only for windows # On Windows, due to the limited command line length, when creating a static library # from a very high number of objects SCons will invoke "ar" once per object file; # that makes object files with same names to be overwritten so the last wins and # the library looses symbols defined by overwritten objects. # By enabling quick append instead of the default mode (replacing), libraries will # got built correctly regardless the invocation strategy. # Furthermore, since SCons will rebuild the library from scratch when an object file # changes, no multiple versions of the same object file will be present. self.Replace(ARFLAGS="q") def mySubProcess(cmdline, env): startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW proc = subprocess.Popen( cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, startupinfo=startupinfo, shell=False, env=env, ) _, err = proc.communicate() rv = proc.wait() if rv: print("=====") print(err) print("=====") return rv def mySpawn(sh, escape, cmd, args, env): newargs = " ".join(args[1:]) cmdline = cmd + " " + newargs rv = 0 env = {str(key): str(value) for key, value in iter(env.items())} if len(cmdline) > 32000 and cmd.endswith("ar"): cmdline = cmd + " " + args[1] + " " + args[2] + " " for i in range(3, len(args)): rv = mySubProcess(cmdline + args[i], env) if rv: break else: rv = mySubProcess(cmdline, env) return rv self["SPAWN"] = mySpawn def save_active_platforms(apnames, ap): for x in ap: names = ["logo"] if os.path.isfile(x + "/run_icon.png"): names.append("run_icon") for name in names: pngf = open(x + "/" + name + ".png", "rb") b = pngf.read(1) str = " /* AUTOGENERATED FILE, DO NOT EDIT */ \n" str += " static const unsigned char _" + x[9:] + "_" + name + "[]={" while len(b) == 1: str += hex(ord(b)) b = pngf.read(1) if len(b) == 1: str += "," str += "};\n" pngf.close() # NOTE: It is safe to generate this file here, since this is still executed serially wf = x + "/" + name + ".gen.h" with open(wf, "w") as pngw: pngw.write(str) def no_verbose(sys, env): colors = {} # Colors are disabled in non-TTY environments such as pipes. This means # that if output is redirected to a file, it will not contain color codes if sys.stdout.isatty(): colors["cyan"] = "\033[96m" colors["purple"] = "\033[95m" colors["blue"] = "\033[94m" colors["green"] = "\033[92m" colors["yellow"] = "\033[93m" colors["red"] = "\033[91m" colors["end"] = "\033[0m" else: colors["cyan"] = "" colors["purple"] = "" colors["blue"] = "" colors["green"] = "" colors["yellow"] = "" colors["red"] = "" colors["end"] = "" compile_source_message = "{}Compiling {}==> {}$SOURCE{}".format( colors["blue"], colors["purple"], colors["yellow"], colors["end"] ) java_compile_source_message = "{}Compiling {}==> {}$SOURCE{}".format( colors["blue"], colors["purple"], colors["yellow"], colors["end"] ) compile_shared_source_message = "{}Compiling shared {}==> {}$SOURCE{}".format( colors["blue"], colors["purple"], colors["yellow"], colors["end"] ) link_program_message = "{}Linking Program {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) link_library_message = "{}Linking Static Library {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) ranlib_library_message = "{}Ranlib Library {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) link_shared_library_message = "{}Linking Shared Library {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) java_library_message = "{}Creating Java Archive {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) env.Append(CXXCOMSTR=[compile_source_message]) env.Append(CCCOMSTR=[compile_source_message]) env.Append(SHCCCOMSTR=[compile_shared_source_message]) env.Append(SHCXXCOMSTR=[compile_shared_source_message]) env.Append(ARCOMSTR=[link_library_message]) env.Append(RANLIBCOMSTR=[ranlib_library_message]) env.Append(SHLINKCOMSTR=[link_shared_library_message]) env.Append(LINKCOMSTR=[link_program_message]) env.Append(JARCOMSTR=[java_library_message]) env.Append(JAVACCOMSTR=[java_compile_source_message]) def detect_visual_c_compiler_version(tools_env): # tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks... # (see the SCons documentation for more information on what it does)... # in order for this function to be well encapsulated i choose to force it to receive SCons's TOOLS env (env['ENV'] # and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect # the proper vc version that will be called # There is no flag to give to visual c compilers to set the architecture, ie scons bits argument (32,64,ARM etc) # There are many different cl.exe files that are run, and each one compiles & links to a different architecture # As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program() # is to check the PATH variable and figure out which one will be called first. Code below does that and returns: # the following string values: # "" Compiler not detected # "amd64" Native 64 bit compiler # "amd64_x86" 64 bit Cross Compiler for 32 bit # "x86" Native 32 bit compiler # "x86_amd64" 32 bit Cross Compiler for 64 bit # There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm # and similar architectures/compilers # Set chosen compiler to "not detected" vc_chosen_compiler_index = -1 vc_chosen_compiler_str = "" # Start with Pre VS 2017 checks which uses VCINSTALLDIR: if "VCINSTALLDIR" in tools_env: # print("Checking VCINSTALLDIR") # find() works with -1 so big ifs below are needed... the simplest solution, in fact # First test if amd64 and amd64_x86 compilers are present in the path vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;") if vc_amd64_compiler_detection_index > -1: vc_chosen_compiler_index = vc_amd64_compiler_detection_index vc_chosen_compiler_str = "amd64" vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;") if vc_amd64_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index vc_chosen_compiler_str = "amd64_x86" # Now check the 32 bit compilers vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;") if vc_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_compiler_detection_index vc_chosen_compiler_str = "x86" vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\x86_amd64;") if vc_x86_amd64_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index vc_chosen_compiler_str = "x86_amd64" # and for VS 2017 and newer we check VCTOOLSINSTALLDIR: if "VCTOOLSINSTALLDIR" in tools_env: # Newer versions have a different path available vc_amd64_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X64;") ) if vc_amd64_compiler_detection_index > -1: vc_chosen_compiler_index = vc_amd64_compiler_detection_index vc_chosen_compiler_str = "amd64" vc_amd64_x86_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X86;") ) if vc_amd64_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index vc_chosen_compiler_str = "amd64_x86" vc_x86_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X86;") ) if vc_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_compiler_detection_index vc_chosen_compiler_str = "x86" vc_x86_amd64_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X64;") ) if vc_x86_amd64_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index vc_chosen_compiler_str = "x86_amd64" return vc_chosen_compiler_str def find_visual_c_batch_file(env): from SCons.Tool.MSCommon.vc import get_default_version, get_host_target, find_batch_file version = get_default_version(env) (host_platform, target_platform, _) = get_host_target(env) return find_batch_file(env, version, host_platform, target_platform)[0] def generate_cpp_hint_file(filename): if os.path.isfile(filename): # Don't overwrite an existing hint file since the user may have customized it. pass else: try: with open(filename, "w") as fd: fd.write("#define GDCLASS(m_class, m_inherits)\n") except OSError: print("Could not write cpp.hint file.") def glob_recursive(pattern, node="."): results = [] for f in Glob(str(node) + "/*", source=True): if type(f) is Node.FS.Dir: results += glob_recursive(pattern, f) results += Glob(str(node) + "/" + pattern, source=True) return results def add_to_vs_project(env, sources): for x in sources: if type(x) == type(""): fname = env.File(x).path else: fname = env.File(x)[0].path pieces = fname.split(".") if len(pieces) > 0: basename = pieces[0] basename = basename.replace("\\\\", "/") if os.path.isfile(basename + ".h"): env.vs_incs += [basename + ".h"] elif os.path.isfile(basename + ".hpp"): env.vs_incs += [basename + ".hpp"] if os.path.isfile(basename + ".c"): env.vs_srcs += [basename + ".c"] elif os.path.isfile(basename + ".cpp"): env.vs_srcs += [basename + ".cpp"] def generate_vs_project(env, num_jobs): batch_file = find_visual_c_batch_file(env) if batch_file: def build_commandline(commands): common_build_prefix = [ 'cmd /V /C set "plat=$(PlatformTarget)"', '(if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64"))', 'set "tools=%s"' % env["tools"], '(if "$(Configuration)"=="release" (set "tools=no"))', 'call "' + batch_file + '" !plat!', ] # windows allows us to have spaces in paths, so we need # to double quote off the directory. However, the path ends # in a backslash, so we need to remove this, lest it escape the # last double quote off, confusing MSBuild common_build_postfix = [ "--directory=\"$(ProjectDir.TrimEnd('\\'))\"", "platform=windows", "target=$(Configuration)", "progress=no", "tools=!tools!", "-j%s" % num_jobs, ] if env["custom_modules"]: common_build_postfix.append("custom_modules=%s" % env["custom_modules"]) result = " ^& ".join(common_build_prefix + [" ".join([commands] + common_build_postfix)]) return result add_to_vs_project(env, env.core_sources) add_to_vs_project(env, env.drivers_sources) add_to_vs_project(env, env.main_sources) add_to_vs_project(env, env.modules_sources) add_to_vs_project(env, env.scene_sources) add_to_vs_project(env, env.servers_sources) add_to_vs_project(env, env.editor_sources) for header in glob_recursive("**/*.h"): env.vs_incs.append(str(header)) env["MSVSBUILDCOM"] = build_commandline("scons") env["MSVSREBUILDCOM"] = build_commandline("scons vsproj=yes") env["MSVSCLEANCOM"] = build_commandline("scons --clean") # This version information (Win32, x64, Debug, Release, Release_Debug seems to be # required for Visual Studio to understand that it needs to generate an NMAKE # project. Do not modify without knowing what you are doing. debug_variants = ["debug|Win32"] + ["debug|x64"] release_variants = ["release|Win32"] + ["release|x64"] release_debug_variants = ["release_debug|Win32"] + ["release_debug|x64"] variants = debug_variants + release_variants + release_debug_variants debug_targets = ["bin\\godot.windows.tools.32.exe"] + ["bin\\godot.windows.tools.64.exe"] release_targets = ["bin\\godot.windows.opt.32.exe"] + ["bin\\godot.windows.opt.64.exe"] release_debug_targets = ["bin\\godot.windows.opt.tools.32.exe"] + ["bin\\godot.windows.opt.tools.64.exe"] targets = debug_targets + release_targets + release_debug_targets if not env.get("MSVS"): env["MSVS"]["PROJECTSUFFIX"] = ".vcxproj" env["MSVS"]["SOLUTIONSUFFIX"] = ".sln" env.MSVSProject( target=["#godot" + env["MSVSPROJECTSUFFIX"]], incs=env.vs_incs, srcs=env.vs_srcs, runfile=targets, buildtarget=targets, auto_build_solution=1, variant=variants, ) else: print("Could not locate Visual Studio batch file to set up the build environment. Not generating VS project.") def precious_program(env, program, sources, **args): program = env.ProgramOriginal(program, sources, **args) env.Precious(program) return program def add_shared_library(env, name, sources, **args): library = env.SharedLibrary(name, sources, **args) env.NoCache(library) return library def add_library(env, name, sources, **args): library = env.Library(name, sources, **args) env.NoCache(library) return library def add_program(env, name, sources, **args): program = env.Program(name, sources, **args) env.NoCache(program) return program def CommandNoCache(env, target, sources, command, **args): result = env.Command(target, sources, command, **args) env.NoCache(result) return result def Run(env, function, short_message, subprocess=True): output_print = short_message if not env["verbose"] else "" if not subprocess: return Action(function, output_print) else: return Action(run_in_subprocess(function), output_print) def detect_darwin_sdk_path(platform, env): sdk_name = "" if platform == "osx": sdk_name = "macosx" var_name = "MACOS_SDK_PATH" elif platform == "iphone": sdk_name = "iphoneos" var_name = "IPHONESDK" elif platform == "iphonesimulator": sdk_name = "iphonesimulator" var_name = "IPHONESDK" else: raise Exception("Invalid platform argument passed to detect_darwin_sdk_path") if not env[var_name]: try: sdk_path = subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip().decode("utf-8") if sdk_path: env[var_name] = sdk_path except (subprocess.CalledProcessError, OSError): print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name)) raise def is_vanilla_clang(env): if not using_clang(env): return False try: version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8") except (subprocess.CalledProcessError, OSError): print("Couldn't parse CXX environment variable to infer compiler version.") return False return not version.startswith("Apple") def get_compiler_version(env): """ Returns an array of version numbers as ints: [major, minor, patch]. The return array should have at least two values (major, minor). """ if not env.msvc: # Not using -dumpversion as some GCC distros only return major, and # Clang used to return hardcoded 4.2.1: # https://reviews.llvm.org/D56803 try: version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8") except (subprocess.CalledProcessError, OSError): print("Couldn't parse CXX environment variable to infer compiler version.") return None else: # TODO: Implement for MSVC return None match = re.search("[0-9]+\.[0-9.]+", version) if match is not None: return list(map(int, match.group().split("."))) else: return None def using_gcc(env): return "gcc" in os.path.basename(env["CC"]) def using_clang(env): return "clang" in os.path.basename(env["CC"]) def show_progress(env): import sys from SCons.Script import Progress, Command, AlwaysBuild screen = sys.stdout # Progress reporting is not available in non-TTY environments since it # messes with the output (for example, when writing to a file) show_progress = env["progress"] and sys.stdout.isatty() node_count = 0 node_count_max = 0 node_count_interval = 1 node_count_fname = str(env.Dir("#")) + "/.scons_node_count" import time, math class cache_progress: # The default is 1 GB cache and 12 hours half life def __init__(self, path=None, limit=1073741824, half_life=43200): self.path = path self.limit = limit self.exponent_scale = math.log(2) / half_life if env["verbose"] and path != None: screen.write( "Current cache limit is {} (used: {})\n".format( self.convert_size(limit), self.convert_size(self.get_size(path)) ) ) self.delete(self.file_list()) def __call__(self, node, *args, **kw): nonlocal node_count, node_count_max, node_count_interval, node_count_fname, show_progress if show_progress: # Print the progress percentage node_count += node_count_interval if node_count_max > 0 and node_count <= node_count_max: screen.write("\r[%3d%%] " % (node_count * 100 / node_count_max)) screen.flush() elif node_count_max > 0 and node_count > node_count_max: screen.write("\r[100%] ") screen.flush() else: screen.write("\r[Initial build] ") screen.flush() def delete(self, files): if len(files) == 0: return if env["verbose"]: # Utter something screen.write("\rPurging %d %s from cache...\n" % (len(files), len(files) > 1 and "files" or "file")) [os.remove(f) for f in files] def file_list(self): if self.path is None: # Nothing to do return [] # Gather a list of (filename, (size, atime)) within the # cache directory file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, "*", "*"))] if file_stat == []: # Nothing to do return [] # Weight the cache files by size (assumed to be roughly # proportional to the recompilation time) times an exponential # decay since the ctime, and return a list with the entries # (filename, size, weight). current_time = time.time() file_stat = [(x[0], x[1][0], (current_time - x[1][1])) for x in file_stat] # Sort by the most recently accessed files (most sensible to keep) first file_stat.sort(key=lambda x: x[2]) # Search for the first entry where the storage limit is # reached sum, mark = 0, None for i, x in enumerate(file_stat): sum += x[1] if sum > self.limit: mark = i break if mark is None: return [] else: return [x[0] for x in file_stat[mark:]] def convert_size(self, size_bytes): if size_bytes == 0: return "0 bytes" size_name = ("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB") i = int(math.floor(math.log(size_bytes, 1024))) p = math.pow(1024, i) s = round(size_bytes / p, 2) return "%s %s" % (int(s) if i == 0 else s, size_name[i]) def get_size(self, start_path="."): total_size = 0 for dirpath, dirnames, filenames in os.walk(start_path): for f in filenames: fp = os.path.join(dirpath, f) total_size += os.path.getsize(fp) return total_size def progress_finish(target, source, env): nonlocal node_count, progressor with open(node_count_fname, "w") as f: f.write("%d\n" % node_count) progressor.delete(progressor.file_list()) try: with open(node_count_fname) as f: node_count_max = int(f.readline()) except: pass cache_directory = os.environ.get("SCONS_CACHE") # Simple cache pruning, attached to SCons' progress callback. Trim the # cache directory to a size not larger than cache_limit. cache_limit = float(os.getenv("SCONS_CACHE_LIMIT", 1024)) * 1024 * 1024 progressor = cache_progress(cache_directory, cache_limit) Progress(progressor, interval=node_count_interval) progress_finish_command = Command("progress_finish", [], progress_finish) AlwaysBuild(progress_finish_command) def dump(env): # Dumps latest build information for debugging purposes and external tools. from json import dump def non_serializable(obj): return "<<non-serializable: %s>>" % (type(obj).__qualname__) with open(".scons_env.json", "w") as f: dump(env.Dictionary(), f, indent=4, default=non_serializable)

38.544304

126

0.607553

import os import re import glob import subprocess from collections import OrderedDict from SCons.Script import Action from SCons import Node from SCons.Script import Glob from platform_methods import run_in_subprocess def add_source_files(self, sources, files, warn_duplicates=True): if isinstance(files, (str, bytes)): if files.startswith("#"): if "*" in files: print("ERROR: Wildcards can't be expanded in SCons project-absolute path: '{}'".format(files)) return files = [files] else: dir_path = self.Dir(".").abspath files = sorted(glob.glob(dir_path + "/" + files)) # Add each path as compiled Object following environment (self) configuration for path in files: obj = self.Object(path) if obj in sources: if warn_duplicates: print('WARNING: Object "{}" already included in environment sources.'.format(obj)) else: continue sources.append(obj) def disable_warnings(self): # 'self' is the environment if self.msvc: # We have to remove existing warning level defines before appending /w, # otherwise we get: "warning D9025 : overriding '/W3' with '/w'" warn_flags = ["/Wall", "/W4", "/W3", "/W2", "/W1", "/WX"] self.Append(CCFLAGS=["/w"]) self.Append(CFLAGS=["/w"]) self.Append(CXXFLAGS=["/w"]) self["CCFLAGS"] = [x for x in self["CCFLAGS"] if not x in warn_flags] self["CFLAGS"] = [x for x in self["CFLAGS"] if not x in warn_flags] self["CXXFLAGS"] = [x for x in self["CXXFLAGS"] if not x in warn_flags] else: self.Append(CCFLAGS=["-w"]) self.Append(CFLAGS=["-w"]) self.Append(CXXFLAGS=["-w"]) def add_module_version_string(self, s): self.module_version_string += "." + s def update_version(module_version_string=""): build_name = "custom_build" if os.getenv("BUILD_NAME") != None: build_name = os.getenv("BUILD_NAME") print("Using custom build name: " + build_name) import version # NOTE: It is safe to generate this file here, since this is still executed serially f = open("core/version_generated.gen.h", "w") f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n") f.write("#ifndef VERSION_GENERATED_GEN_H\n") f.write("#define VERSION_GENERATED_GEN_H\n") f.write(' f.write(' f.write("#define VERSION_MAJOR " + str(version.major) + "\n") f.write("#define VERSION_MINOR " + str(version.minor) + "\n") f.write("#define VERSION_PATCH " + str(version.patch) + "\n") f.write(' f.write(' f.write(' f.write("#define VERSION_YEAR " + str(version.year) + "\n") f.write(' f.write("#endif // VERSION_GENERATED_GEN_H\n") f.close() # NOTE: It is safe to generate this file here, since this is still executed serially fhash = open("core/version_hash.gen.h", "w") fhash.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n") fhash.write("#ifndef VERSION_HASH_GEN_H\n") fhash.write("#define VERSION_HASH_GEN_H\n") githash = "" gitfolder = ".git" if os.path.isfile(".git"): module_folder = open(".git", "r").readline().strip() if module_folder.startswith("gitdir: "): gitfolder = module_folder[8:] if os.path.isfile(os.path.join(gitfolder, "HEAD")): head = open(os.path.join(gitfolder, "HEAD"), "r", encoding="utf8").readline().strip() if head.startswith("ref: "): head = os.path.join(gitfolder, head[5:]) if os.path.isfile(head): githash = open(head, "r").readline().strip() else: githash = head fhash.write(' fhash.write("#endif // VERSION_HASH_GEN_H\n") fhash.close() def parse_cg_file(fname, uniforms, sizes, conditionals): fs = open(fname, "r") line = fs.readline() while line: if re.match(r"^\s*uniform", line): res = re.match(r"uniform ([\d\w]*) ([\d\w]*)") type = res.groups(1) name = res.groups(2) uniforms.append(name) if type.find("texobj") != -1: sizes.append(1) else: t = re.match(r"float(\d)x(\d)", type) if t: sizes.append(int(t.groups(1)) * int(t.groups(2))) else: t = re.match(r"float(\d)", type) sizes.append(int(t.groups(1))) if line.find("[branch]") != -1: conditionals.append(name) line = fs.readline() fs.close() def detect_modules(at_path): module_list = OrderedDict() # name : path modules_glob = os.path.join(at_path, "*") files = glob.glob(modules_glob) files.sort() # so register_module_types does not change that often, and also plugins are registered in alphabetic order for x in files: if not is_module(x): continue name = os.path.basename(x) path = x.replace("\\", "/") # win32 module_list[name] = path return module_list def is_module(path): return os.path.isdir(path) and os.path.exists(os.path.join(path, "SCsub")) def write_modules(module_list): includes_cpp = "" preregister_cpp = "" register_cpp = "" unregister_cpp = "" for name, path in module_list.items(): try: with open(os.path.join(path, "register_types.h")): includes_cpp += ' preregister_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n" preregister_cpp += "#ifdef MODULE_" + name.upper() + "_HAS_PREREGISTER\n" preregister_cpp += "\tpreregister_" + name + "_types();\n" preregister_cpp += "#endif\n" preregister_cpp += "#endif\n" register_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n" register_cpp += "\tregister_" + name + "_types();\n" register_cpp += "#endif\n" unregister_cpp += "#ifdef MODULE_" + name.upper() + "_ENABLED\n" unregister_cpp += "\tunregister_" + name + "_types();\n" unregister_cpp += "#endif\n" except OSError: pass modules_cpp = """// register_module_types.gen.cpp /* THIS FILE IS GENERATED DO NOT EDIT */ #include "register_module_types.h" #include "modules/modules_enabled.gen.h" %s void preregister_module_types() { %s } void register_module_types() { %s } void unregister_module_types() { %s } """ % ( includes_cpp, preregister_cpp, register_cpp, unregister_cpp, ) # NOTE: It is safe to generate this file here, since this is still executed serially with open("modules/register_module_types.gen.cpp", "w") as f: f.write(modules_cpp) def convert_custom_modules_path(path): if not path: return path path = os.path.realpath(os.path.expanduser(os.path.expandvars(path))) err_msg = "Build option 'custom_modules' must %s" if not os.path.isdir(path): raise ValueError(err_msg % "point to an existing directory.") if path == os.path.realpath("modules"): raise ValueError(err_msg % "be a directory other than built-in `modules` directory.") if is_module(path): raise ValueError(err_msg % "point to a directory with modules, not a single module.") return path def disable_module(self): self.disabled_modules.append(self.current_module) def module_check_dependencies(self, module, dependencies): missing_deps = [] for dep in dependencies: opt = "module_{}_enabled".format(dep) if not opt in self or not self[opt]: missing_deps.append(dep) if missing_deps != []: print( "Disabling '{}' module as the following dependencies are not satisfied: {}".format( module, ", ".join(missing_deps) ) ) return False else: return True def use_windows_spawn_fix(self, platform=None): if os.name != "nt": return # not needed, only for windows # On Windows, due to the limited command line length, when creating a static library # from a very high number of objects SCons will invoke "ar" once per object file; # that makes object files with same names to be overwritten so the last wins and # the library looses symbols defined by overwritten objects. # By enabling quick append instead of the default mode (replacing), libraries will # got built correctly regardless the invocation strategy. # Furthermore, since SCons will rebuild the library from scratch when an object file # changes, no multiple versions of the same object file will be present. self.Replace(ARFLAGS="q") def mySubProcess(cmdline, env): startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW proc = subprocess.Popen( cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, startupinfo=startupinfo, shell=False, env=env, ) _, err = proc.communicate() rv = proc.wait() if rv: print("=====") print(err) print("=====") return rv def mySpawn(sh, escape, cmd, args, env): newargs = " ".join(args[1:]) cmdline = cmd + " " + newargs rv = 0 env = {str(key): str(value) for key, value in iter(env.items())} if len(cmdline) > 32000 and cmd.endswith("ar"): cmdline = cmd + " " + args[1] + " " + args[2] + " " for i in range(3, len(args)): rv = mySubProcess(cmdline + args[i], env) if rv: break else: rv = mySubProcess(cmdline, env) return rv self["SPAWN"] = mySpawn def save_active_platforms(apnames, ap): for x in ap: names = ["logo"] if os.path.isfile(x + "/run_icon.png"): names.append("run_icon") for name in names: pngf = open(x + "/" + name + ".png", "rb") b = pngf.read(1) str = " /* AUTOGENERATED FILE, DO NOT EDIT */ \n" str += " static const unsigned char _" + x[9:] + "_" + name + "[]={" while len(b) == 1: str += hex(ord(b)) b = pngf.read(1) if len(b) == 1: str += "," str += "};\n" pngf.close() # NOTE: It is safe to generate this file here, since this is still executed serially wf = x + "/" + name + ".gen.h" with open(wf, "w") as pngw: pngw.write(str) def no_verbose(sys, env): colors = {} # Colors are disabled in non-TTY environments such as pipes. This means # that if output is redirected to a file, it will not contain color codes if sys.stdout.isatty(): colors["cyan"] = "\033[96m" colors["purple"] = "\033[95m" colors["blue"] = "\033[94m" colors["green"] = "\033[92m" colors["yellow"] = "\033[93m" colors["red"] = "\033[91m" colors["end"] = "\033[0m" else: colors["cyan"] = "" colors["purple"] = "" colors["blue"] = "" colors["green"] = "" colors["yellow"] = "" colors["red"] = "" colors["end"] = "" compile_source_message = "{}Compiling {}==> {}$SOURCE{}".format( colors["blue"], colors["purple"], colors["yellow"], colors["end"] ) java_compile_source_message = "{}Compiling {}==> {}$SOURCE{}".format( colors["blue"], colors["purple"], colors["yellow"], colors["end"] ) compile_shared_source_message = "{}Compiling shared {}==> {}$SOURCE{}".format( colors["blue"], colors["purple"], colors["yellow"], colors["end"] ) link_program_message = "{}Linking Program {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) link_library_message = "{}Linking Static Library {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) ranlib_library_message = "{}Ranlib Library {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) link_shared_library_message = "{}Linking Shared Library {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) java_library_message = "{}Creating Java Archive {}==> {}$TARGET{}".format( colors["red"], colors["purple"], colors["yellow"], colors["end"] ) env.Append(CXXCOMSTR=[compile_source_message]) env.Append(CCCOMSTR=[compile_source_message]) env.Append(SHCCCOMSTR=[compile_shared_source_message]) env.Append(SHCXXCOMSTR=[compile_shared_source_message]) env.Append(ARCOMSTR=[link_library_message]) env.Append(RANLIBCOMSTR=[ranlib_library_message]) env.Append(SHLINKCOMSTR=[link_shared_library_message]) env.Append(LINKCOMSTR=[link_program_message]) env.Append(JARCOMSTR=[java_library_message]) env.Append(JAVACCOMSTR=[java_compile_source_message]) def detect_visual_c_compiler_version(tools_env): # tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks... # and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect # the proper vc version that will be called # There is no flag to give to visual c compilers to set the architecture, ie scons bits argument (32,64,ARM etc) # There are many different cl.exe files that are run, and each one compiles & links to a different architecture # As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program() # is to check the PATH variable and figure out which one will be called first. Code below does that and returns: # the following string values: # "" Compiler not detected # "amd64" Native 64 bit compiler # "amd64_x86" 64 bit Cross Compiler for 32 bit # "x86" Native 32 bit compiler # "x86_amd64" 32 bit Cross Compiler for 64 bit # There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm # and similar architectures/compilers # Set chosen compiler to "not detected" vc_chosen_compiler_index = -1 vc_chosen_compiler_str = "" # Start with Pre VS 2017 checks which uses VCINSTALLDIR: if "VCINSTALLDIR" in tools_env: # print("Checking VCINSTALLDIR") # find() works with -1 so big ifs below are needed... the simplest solution, in fact # First test if amd64 and amd64_x86 compilers are present in the path vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;") if vc_amd64_compiler_detection_index > -1: vc_chosen_compiler_index = vc_amd64_compiler_detection_index vc_chosen_compiler_str = "amd64" vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;") if vc_amd64_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index vc_chosen_compiler_str = "amd64_x86" # Now check the 32 bit compilers vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;") if vc_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_compiler_detection_index vc_chosen_compiler_str = "x86" vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\x86_amd64;") if vc_x86_amd64_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index vc_chosen_compiler_str = "x86_amd64" # and for VS 2017 and newer we check VCTOOLSINSTALLDIR: if "VCTOOLSINSTALLDIR" in tools_env: # Newer versions have a different path available vc_amd64_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X64;") ) if vc_amd64_compiler_detection_index > -1: vc_chosen_compiler_index = vc_amd64_compiler_detection_index vc_chosen_compiler_str = "amd64" vc_amd64_x86_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX64\\X86;") ) if vc_amd64_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index vc_chosen_compiler_str = "amd64_x86" vc_x86_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X86;") ) if vc_x86_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_compiler_detection_index vc_chosen_compiler_str = "x86" vc_x86_amd64_compiler_detection_index = ( tools_env["PATH"].upper().find(tools_env["VCTOOLSINSTALLDIR"].upper() + "BIN\\HOSTX86\\X64;") ) if vc_x86_amd64_compiler_detection_index > -1 and ( vc_chosen_compiler_index == -1 or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index ): vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index vc_chosen_compiler_str = "x86_amd64" return vc_chosen_compiler_str def find_visual_c_batch_file(env): from SCons.Tool.MSCommon.vc import get_default_version, get_host_target, find_batch_file version = get_default_version(env) (host_platform, target_platform, _) = get_host_target(env) return find_batch_file(env, version, host_platform, target_platform)[0] def generate_cpp_hint_file(filename): if os.path.isfile(filename): # Don't overwrite an existing hint file since the user may have customized it. pass else: try: with open(filename, "w") as fd: fd.write("#define GDCLASS(m_class, m_inherits)\n") except OSError: print("Could not write cpp.hint file.") def glob_recursive(pattern, node="."): results = [] for f in Glob(str(node) + "/*", source=True): if type(f) is Node.FS.Dir: results += glob_recursive(pattern, f) results += Glob(str(node) + "/" + pattern, source=True) return results def add_to_vs_project(env, sources): for x in sources: if type(x) == type(""): fname = env.File(x).path else: fname = env.File(x)[0].path pieces = fname.split(".") if len(pieces) > 0: basename = pieces[0] basename = basename.replace("\\\\", "/") if os.path.isfile(basename + ".h"): env.vs_incs += [basename + ".h"] elif os.path.isfile(basename + ".hpp"): env.vs_incs += [basename + ".hpp"] if os.path.isfile(basename + ".c"): env.vs_srcs += [basename + ".c"] elif os.path.isfile(basename + ".cpp"): env.vs_srcs += [basename + ".cpp"] def generate_vs_project(env, num_jobs): batch_file = find_visual_c_batch_file(env) if batch_file: def build_commandline(commands): common_build_prefix = [ 'cmd /V /C set "plat=$(PlatformTarget)"', '(if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64"))', 'set "tools=%s"' % env["tools"], '(if "$(Configuration)"=="release" (set "tools=no"))', 'call "' + batch_file + '" !plat!', ] common_build_postfix = [ "--directory=\"$(ProjectDir.TrimEnd('\\'))\"", "platform=windows", "target=$(Configuration)", "progress=no", "tools=!tools!", "-j%s" % num_jobs, ] if env["custom_modules"]: common_build_postfix.append("custom_modules=%s" % env["custom_modules"]) result = " ^& ".join(common_build_prefix + [" ".join([commands] + common_build_postfix)]) return result add_to_vs_project(env, env.core_sources) add_to_vs_project(env, env.drivers_sources) add_to_vs_project(env, env.main_sources) add_to_vs_project(env, env.modules_sources) add_to_vs_project(env, env.scene_sources) add_to_vs_project(env, env.servers_sources) add_to_vs_project(env, env.editor_sources) for header in glob_recursive("**/*.h"): env.vs_incs.append(str(header)) env["MSVSBUILDCOM"] = build_commandline("scons") env["MSVSREBUILDCOM"] = build_commandline("scons vsproj=yes") env["MSVSCLEANCOM"] = build_commandline("scons --clean") debug_variants = ["debug|Win32"] + ["debug|x64"] release_variants = ["release|Win32"] + ["release|x64"] release_debug_variants = ["release_debug|Win32"] + ["release_debug|x64"] variants = debug_variants + release_variants + release_debug_variants debug_targets = ["bin\\godot.windows.tools.32.exe"] + ["bin\\godot.windows.tools.64.exe"] release_targets = ["bin\\godot.windows.opt.32.exe"] + ["bin\\godot.windows.opt.64.exe"] release_debug_targets = ["bin\\godot.windows.opt.tools.32.exe"] + ["bin\\godot.windows.opt.tools.64.exe"] targets = debug_targets + release_targets + release_debug_targets if not env.get("MSVS"): env["MSVS"]["PROJECTSUFFIX"] = ".vcxproj" env["MSVS"]["SOLUTIONSUFFIX"] = ".sln" env.MSVSProject( target=["#godot" + env["MSVSPROJECTSUFFIX"]], incs=env.vs_incs, srcs=env.vs_srcs, runfile=targets, buildtarget=targets, auto_build_solution=1, variant=variants, ) else: print("Could not locate Visual Studio batch file to set up the build environment. Not generating VS project.") def precious_program(env, program, sources, **args): program = env.ProgramOriginal(program, sources, **args) env.Precious(program) return program def add_shared_library(env, name, sources, **args): library = env.SharedLibrary(name, sources, **args) env.NoCache(library) return library def add_library(env, name, sources, **args): library = env.Library(name, sources, **args) env.NoCache(library) return library def add_program(env, name, sources, **args): program = env.Program(name, sources, **args) env.NoCache(program) return program def CommandNoCache(env, target, sources, command, **args): result = env.Command(target, sources, command, **args) env.NoCache(result) return result def Run(env, function, short_message, subprocess=True): output_print = short_message if not env["verbose"] else "" if not subprocess: return Action(function, output_print) else: return Action(run_in_subprocess(function), output_print) def detect_darwin_sdk_path(platform, env): sdk_name = "" if platform == "osx": sdk_name = "macosx" var_name = "MACOS_SDK_PATH" elif platform == "iphone": sdk_name = "iphoneos" var_name = "IPHONESDK" elif platform == "iphonesimulator": sdk_name = "iphonesimulator" var_name = "IPHONESDK" else: raise Exception("Invalid platform argument passed to detect_darwin_sdk_path") if not env[var_name]: try: sdk_path = subprocess.check_output(["xcrun", "--sdk", sdk_name, "--show-sdk-path"]).strip().decode("utf-8") if sdk_path: env[var_name] = sdk_path except (subprocess.CalledProcessError, OSError): print("Failed to find SDK path while running xcrun --sdk {} --show-sdk-path.".format(sdk_name)) raise def is_vanilla_clang(env): if not using_clang(env): return False try: version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8") except (subprocess.CalledProcessError, OSError): print("Couldn't parse CXX environment variable to infer compiler version.") return False return not version.startswith("Apple") def get_compiler_version(env): if not env.msvc: # Not using -dumpversion as some GCC distros only return major, and # Clang used to return hardcoded 4.2.1: # https://reviews.llvm.org/D56803 try: version = subprocess.check_output([env.subst(env["CXX"]), "--version"]).strip().decode("utf-8") except (subprocess.CalledProcessError, OSError): print("Couldn't parse CXX environment variable to infer compiler version.") return None else: return None match = re.search("[0-9]+\.[0-9.]+", version) if match is not None: return list(map(int, match.group().split("."))) else: return None def using_gcc(env): return "gcc" in os.path.basename(env["CC"]) def using_clang(env): return "clang" in os.path.basename(env["CC"]) def show_progress(env): import sys from SCons.Script import Progress, Command, AlwaysBuild screen = sys.stdout show_progress = env["progress"] and sys.stdout.isatty() node_count = 0 node_count_max = 0 node_count_interval = 1 node_count_fname = str(env.Dir("#")) + "/.scons_node_count" import time, math class cache_progress: def __init__(self, path=None, limit=1073741824, half_life=43200): self.path = path self.limit = limit self.exponent_scale = math.log(2) / half_life if env["verbose"] and path != None: screen.write( "Current cache limit is {} (used: {})\n".format( self.convert_size(limit), self.convert_size(self.get_size(path)) ) ) self.delete(self.file_list()) def __call__(self, node, *args, **kw): nonlocal node_count, node_count_max, node_count_interval, node_count_fname, show_progress if show_progress: node_count += node_count_interval if node_count_max > 0 and node_count <= node_count_max: screen.write("\r[%3d%%] " % (node_count * 100 / node_count_max)) screen.flush() elif node_count_max > 0 and node_count > node_count_max: screen.write("\r[100%] ") screen.flush() else: screen.write("\r[Initial build] ") screen.flush() def delete(self, files): if len(files) == 0: return if env["verbose"]: screen.write("\rPurging %d %s from cache...\n" % (len(files), len(files) > 1 and "files" or "file")) [os.remove(f) for f in files] def file_list(self): if self.path is None: return [] file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, "*", "*"))] if file_stat == []: return [] current_time = time.time() file_stat = [(x[0], x[1][0], (current_time - x[1][1])) for x in file_stat] file_stat.sort(key=lambda x: x[2]) sum, mark = 0, None for i, x in enumerate(file_stat): sum += x[1] if sum > self.limit: mark = i break if mark is None: return [] else: return [x[0] for x in file_stat[mark:]] def convert_size(self, size_bytes): if size_bytes == 0: return "0 bytes" size_name = ("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB") i = int(math.floor(math.log(size_bytes, 1024))) p = math.pow(1024, i) s = round(size_bytes / p, 2) return "%s %s" % (int(s) if i == 0 else s, size_name[i]) def get_size(self, start_path="."): total_size = 0 for dirpath, dirnames, filenames in os.walk(start_path): for f in filenames: fp = os.path.join(dirpath, f) total_size += os.path.getsize(fp) return total_size def progress_finish(target, source, env): nonlocal node_count, progressor with open(node_count_fname, "w") as f: f.write("%d\n" % node_count) progressor.delete(progressor.file_list()) try: with open(node_count_fname) as f: node_count_max = int(f.readline()) except: pass cache_directory = os.environ.get("SCONS_CACHE") # cache directory to a size not larger than cache_limit. cache_limit = float(os.getenv("SCONS_CACHE_LIMIT", 1024)) * 1024 * 1024 progressor = cache_progress(cache_directory, cache_limit) Progress(progressor, interval=node_count_interval) progress_finish_command = Command("progress_finish", [], progress_finish) AlwaysBuild(progress_finish_command) def dump(env): # Dumps latest build information for debugging purposes and external tools. from json import dump def non_serializable(obj): return "<<non-serializable: %s>>" % (type(obj).__qualname__) with open(".scons_env.json", "w") as f: dump(env.Dictionary(), f, indent=4, default=non_serializable)

true

f7134bc3a14846ee6540a43af0958ad969f6b13e

2,200

py

Python

var/spack/repos/builtin/packages/r-rhtslib/package.py

kkauder/spack

6ae8d5c380c1f42094b05d38be26b03650aafb39

[ "ECL-2.0", "Apache-2.0", "MIT-0", "MIT" ]

2

2020-09-10T22:50:08.000Z

2021-01-12T22:18:54.000Z

var/spack/repos/builtin/packages/r-rhtslib/package.py

kkauder/spack

6ae8d5c380c1f42094b05d38be26b03650aafb39

[ "ECL-2.0", "Apache-2.0", "MIT-0", "MIT" ]

14

2021-07-20T01:04:53.000Z

2022-03-02T01:08:36.000Z

var/spack/repos/builtin/packages/r-rhtslib/package.py

kkauder/spack

6ae8d5c380c1f42094b05d38be26b03650aafb39

[ "ECL-2.0", "Apache-2.0", "MIT-0", "MIT" ]

1

2021-05-06T00:17:46.000Z

# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other # Spack Project Developers. See the top-level COPYRIGHT file for details. # # SPDX-License-Identifier: (Apache-2.0 OR MIT) from spack import * class RRhtslib(RPackage): """HTSlib high-throughput sequencing library as an R package. This package provides version 1.7 of the 'HTSlib' C library for high- throughput sequence analysis. The package is primarily useful to developers of other R packages who wish to make use of HTSlib. Motivation and instructions for use of this package are in the vignette, vignette(package="Rhtslib", "Rhtslib").""" homepage = "https://bioconductor.org/packages/Rhtslib" git = "https://git.bioconductor.org/packages/Rhtslib.git" version('1.18.1', commit='751a2ebaed43b7991204b27bd6c7870645001d82') version('1.16.3', commit='3ed0b5db2ee3cf0df1c6096fde8855c8485eebd4') version('1.14.1', commit='4be260720f845a34d0ac838278fce1363f645230') version('1.12.1', commit='e3487b1355995d09b28fde5d0a7504a3e79a7203') version('1.10.0', commit='53dcf7dfe35d735283956c77c011a97ca3f4eb26') version('1.8.0', commit='3b5493473bed42958614091c58c739932ffcfa79') depends_on('r-zlibbioc', type=('build', 'run')) depends_on('bzip2', type=('build', 'link', 'run')) depends_on('xz', type=('build', 'link', 'run')) depends_on('curl', type=('build', 'link', 'run')) depends_on('gmake', type='build') # Some versions of this package will leave the temporary installation # directory in the htslib shared object. R will fix this if patchelf is # available depends_on('patchelf', when='@1.12:1.14', type='build') patch('use_spack_Makeconf.patch', when='@1.12:') patch('find_deps-1.12.patch', when='@1.12:1.14') patch('find_deps-1.16.patch', when='@1.16:') @when('@1.12:') def setup_build_environment(self, env): env.set('BZIP2_INCLUDE', self.spec['bzip2'].headers.include_flags) env.set('XZ_INCLUDE', self.spec['xz'].headers.include_flags) env.set('BZIP2_LIB', self.spec['bzip2'].libs.search_flags) env.set('XZ_LIB', self.spec['xz'].libs.search_flags)

44

79

0.697727

from spack import * class RRhtslib(RPackage): homepage = "https://bioconductor.org/packages/Rhtslib" git = "https://git.bioconductor.org/packages/Rhtslib.git" version('1.18.1', commit='751a2ebaed43b7991204b27bd6c7870645001d82') version('1.16.3', commit='3ed0b5db2ee3cf0df1c6096fde8855c8485eebd4') version('1.14.1', commit='4be260720f845a34d0ac838278fce1363f645230') version('1.12.1', commit='e3487b1355995d09b28fde5d0a7504a3e79a7203') version('1.10.0', commit='53dcf7dfe35d735283956c77c011a97ca3f4eb26') version('1.8.0', commit='3b5493473bed42958614091c58c739932ffcfa79') depends_on('r-zlibbioc', type=('build', 'run')) depends_on('bzip2', type=('build', 'link', 'run')) depends_on('xz', type=('build', 'link', 'run')) depends_on('curl', type=('build', 'link', 'run')) depends_on('gmake', type='build') depends_on('patchelf', when='@1.12:1.14', type='build') patch('use_spack_Makeconf.patch', when='@1.12:') patch('find_deps-1.12.patch', when='@1.12:1.14') patch('find_deps-1.16.patch', when='@1.16:') @when('@1.12:') def setup_build_environment(self, env): env.set('BZIP2_INCLUDE', self.spec['bzip2'].headers.include_flags) env.set('XZ_INCLUDE', self.spec['xz'].headers.include_flags) env.set('BZIP2_LIB', self.spec['bzip2'].libs.search_flags) env.set('XZ_LIB', self.spec['xz'].libs.search_flags)

true

f7134c6221b780e7e593abd9901e995324b0e639

1,533

py

Python

examples/examples2.py

Maffblaster/pyrtf

b9483af08df4e15c7271ff3013cacf2f80c9a8de

[ "MIT" ]

5

2015-01-27T08:08:08.000Z

2022-03-30T10:43:31.000Z

examples/examples2.py

Maffblaster/pyrtf

b9483af08df4e15c7271ff3013cacf2f80c9a8de

[ "MIT" ]

null

examples/examples2.py

Maffblaster/pyrtf

b9483af08df4e15c7271ff3013cacf2f80c9a8de

[ "MIT" ]

4

2015-12-11T07:41:24.000Z

2022-03-30T09:48:55.000Z

import os import sys sys.path.append( '../' ) from rtfng import * def MakeExample1() : doc = Document() ss = doc.StyleSheet section = Section() doc.Sections.append( section ) # text can be added directly to the section # a paragraph object is create as needed section.append( 'Image Example 1' ) section.append( 'You can add images in one of two ways, either converting the ' 'image each and every time like;' ) image = Image( 'examples/image.jpg' ) section.append( Paragraph( image ) ) section.append( 'Or you can use the image object to convert the image and then ' 'save it to a raw code element that can be included later.' ) fout = file( 'image_tmp.py', 'w' ) print >> fout, 'from rtfng import RawCode' print >> fout fout.write( image.ToRawCode( 'TEST_IMAGE' ) ) fout.close() import image_tmp section.append( Paragraph( image_tmp.TEST_IMAGE ) ) section.append( 'Have a look in image_tmp.py for the converted RawCode.' ) section.append( 'here are some png files' ) for f in [ 'examples/img1.png', 'examples/img2.png', 'examples/img3.png', 'examples/img4.png' ] : section.append( Paragraph( Image( f ) ) ) return doc def OpenFile( name ) : return file( '%s.rtf' % name, 'w' ) if __name__ == '__main__' : DR = Renderer() doc1 = MakeExample1() DR.Write( doc1, OpenFile( 'Image1' ) ) print "Finished"

26.894737

84

0.605349

import os import sys sys.path.append( '../' ) from rtfng import * def MakeExample1() : doc = Document() ss = doc.StyleSheet section = Section() doc.Sections.append( section ) section.append( 'Image Example 1' ) section.append( 'You can add images in one of two ways, either converting the ' 'image each and every time like;' ) image = Image( 'examples/image.jpg' ) section.append( Paragraph( image ) ) section.append( 'Or you can use the image object to convert the image and then ' 'save it to a raw code element that can be included later.' ) fout = file( 'image_tmp.py', 'w' ) print >> fout, 'from rtfng import RawCode' print >> fout fout.write( image.ToRawCode( 'TEST_IMAGE' ) ) fout.close() import image_tmp section.append( Paragraph( image_tmp.TEST_IMAGE ) ) section.append( 'Have a look in image_tmp.py for the converted RawCode.' ) section.append( 'here are some png files' ) for f in [ 'examples/img1.png', 'examples/img2.png', 'examples/img3.png', 'examples/img4.png' ] : section.append( Paragraph( Image( f ) ) ) return doc def OpenFile( name ) : return file( '%s.rtf' % name, 'w' ) if __name__ == '__main__' : DR = Renderer() doc1 = MakeExample1() DR.Write( doc1, OpenFile( 'Image1' ) ) print "Finished"

false

true

f7134ce3b382d03a111cc82338cf645898f111d2

10,824

py

Python

Modules/FirstPythonProject/venv/Lib/site-packages/elasticsearch/client/ccr.py

Malligarjunan/MyLearning

18fdf16b7473a1286b5023a19f3f9d42681c315b

[ "Unlicense" ]

3

2022-02-15T08:18:28.000Z

2022-02-15T10:31:14.000Z

Server/venv/lib/python3.8/site-packages/elasticsearch/client/ccr.py

MarikenvdVelden/living_hub

24709071640ff05b3aa17d214ae4e49901d3e4c5

[ "MIT" ]

null

Server/venv/lib/python3.8/site-packages/elasticsearch/client/ccr.py

MarikenvdVelden/living_hub

24709071640ff05b3aa17d214ae4e49901d3e4c5

[ "MIT" ]

null

# Licensed to Elasticsearch B.V. under one or more contributor # license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright # ownership. Elasticsearch B.V. 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. from .utils import SKIP_IN_PATH, NamespacedClient, _make_path, query_params class CcrClient(NamespacedClient): @query_params() def delete_auto_follow_pattern(self, name, params=None, headers=None): """ Deletes auto-follow patterns. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-delete-auto-follow-pattern.html>`_ :arg name: The name of the auto follow pattern. """ if name in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'name'.") return self.transport.perform_request( "DELETE", _make_path("_ccr", "auto_follow", name), params=params, headers=headers, ) @query_params("wait_for_active_shards") def follow(self, index, body, params=None, headers=None): """ Creates a new follower index configured to follow the referenced leader index. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-put-follow.html>`_ :arg index: The name of the follower index :arg body: The name of the leader index and other optional ccr related parameters :arg wait_for_active_shards: Sets the number of shard copies that must be active before returning. Defaults to 0. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1) Default: 0 """ for param in (index, body): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return self.transport.perform_request( "PUT", _make_path(index, "_ccr", "follow"), params=params, headers=headers, body=body, ) @query_params() def follow_info(self, index, params=None, headers=None): """ Retrieves information about all follower indices, including parameters and status for each follower index `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-get-follow-info.html>`_ :arg index: A comma-separated list of index patterns; use `_all` to perform the operation on all indices """ if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "GET", _make_path(index, "_ccr", "info"), params=params, headers=headers ) @query_params() def follow_stats(self, index, params=None, headers=None): """ Retrieves follower stats. return shard-level stats about the following tasks associated with each shard for the specified indices. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-get-follow-stats.html>`_ :arg index: A comma-separated list of index patterns; use `_all` to perform the operation on all indices """ if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "GET", _make_path(index, "_ccr", "stats"), params=params, headers=headers ) @query_params() def forget_follower(self, index, body, params=None, headers=None): """ Removes the follower retention leases from the leader. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-post-forget-follower.html>`_ :arg index: the name of the leader index for which specified follower retention leases should be removed :arg body: the name and UUID of the follower index, the name of the cluster containing the follower index, and the alias from the perspective of that cluster for the remote cluster containing the leader index """ for param in (index, body): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "forget_follower"), params=params, headers=headers, body=body, ) @query_params() def get_auto_follow_pattern(self, name=None, params=None, headers=None): """ Gets configured auto-follow patterns. Returns the specified auto-follow pattern collection. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-get-auto-follow-pattern.html>`_ :arg name: The name of the auto follow pattern. """ return self.transport.perform_request( "GET", _make_path("_ccr", "auto_follow", name), params=params, headers=headers, ) @query_params() def pause_follow(self, index, params=None, headers=None): """ Pauses a follower index. The follower index will not fetch any additional operations from the leader index. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-post-pause-follow.html>`_ :arg index: The name of the follower index that should pause following its leader index. """ if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "pause_follow"), params=params, headers=headers, ) @query_params() def put_auto_follow_pattern(self, name, body, params=None, headers=None): """ Creates a new named collection of auto-follow patterns against a specified remote cluster. Newly created indices on the remote cluster matching any of the specified patterns will be automatically configured as follower indices. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-put-auto-follow-pattern.html>`_ :arg name: The name of the auto follow pattern. :arg body: The specification of the auto follow pattern """ for param in (name, body): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return self.transport.perform_request( "PUT", _make_path("_ccr", "auto_follow", name), params=params, headers=headers, body=body, ) @query_params() def resume_follow(self, index, body=None, params=None, headers=None): """ Resumes a follower index that has been paused `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-post-resume-follow.html>`_ :arg index: The name of the follow index to resume following. :arg body: The name of the leader index and other optional ccr related parameters """ if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "resume_follow"), params=params, headers=headers, body=body, ) @query_params() def stats(self, params=None, headers=None): """ Gets all stats related to cross-cluster replication. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-get-stats.html>`_ """ return self.transport.perform_request( "GET", "/_ccr/stats", params=params, headers=headers ) @query_params() def unfollow(self, index, params=None, headers=None): """ Stops the following task associated with a follower index and removes index metadata and settings associated with cross-cluster replication. `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-post-unfollow.html>`_ :arg index: The name of the follower index that should be turned into a regular index. """ if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "unfollow"), params=params, headers=headers, ) @query_params() def pause_auto_follow_pattern(self, name, params=None, headers=None): """ Pauses an auto-follow pattern `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-pause-auto-follow-pattern.html>`_ :arg name: The name of the auto follow pattern that should pause discovering new indices to follow. """ if name in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'name'.") return self.transport.perform_request( "POST", _make_path("_ccr", "auto_follow", name, "pause"), params=params, headers=headers, ) @query_params() def resume_auto_follow_pattern(self, name, params=None, headers=None): """ Resumes an auto-follow pattern that has been paused `<https://www.elastic.co/guide/en/elasticsearch/reference/7.14/ccr-resume-auto-follow-pattern.html>`_ :arg name: The name of the auto follow pattern to resume discovering new indices to follow. """ if name in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'name'.") return self.transport.perform_request( "POST", _make_path("_ccr", "auto_follow", name, "resume"), params=params, headers=headers, )

37.846154

109

0.632761

from .utils import SKIP_IN_PATH, NamespacedClient, _make_path, query_params class CcrClient(NamespacedClient): @query_params() def delete_auto_follow_pattern(self, name, params=None, headers=None): if name in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'name'.") return self.transport.perform_request( "DELETE", _make_path("_ccr", "auto_follow", name), params=params, headers=headers, ) @query_params("wait_for_active_shards") def follow(self, index, body, params=None, headers=None): for param in (index, body): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return self.transport.perform_request( "PUT", _make_path(index, "_ccr", "follow"), params=params, headers=headers, body=body, ) @query_params() def follow_info(self, index, params=None, headers=None): if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "GET", _make_path(index, "_ccr", "info"), params=params, headers=headers ) @query_params() def follow_stats(self, index, params=None, headers=None): if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "GET", _make_path(index, "_ccr", "stats"), params=params, headers=headers ) @query_params() def forget_follower(self, index, body, params=None, headers=None): for param in (index, body): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "forget_follower"), params=params, headers=headers, body=body, ) @query_params() def get_auto_follow_pattern(self, name=None, params=None, headers=None): return self.transport.perform_request( "GET", _make_path("_ccr", "auto_follow", name), params=params, headers=headers, ) @query_params() def pause_follow(self, index, params=None, headers=None): if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "pause_follow"), params=params, headers=headers, ) @query_params() def put_auto_follow_pattern(self, name, body, params=None, headers=None): for param in (name, body): if param in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument.") return self.transport.perform_request( "PUT", _make_path("_ccr", "auto_follow", name), params=params, headers=headers, body=body, ) @query_params() def resume_follow(self, index, body=None, params=None, headers=None): if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "resume_follow"), params=params, headers=headers, body=body, ) @query_params() def stats(self, params=None, headers=None): return self.transport.perform_request( "GET", "/_ccr/stats", params=params, headers=headers ) @query_params() def unfollow(self, index, params=None, headers=None): if index in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'index'.") return self.transport.perform_request( "POST", _make_path(index, "_ccr", "unfollow"), params=params, headers=headers, ) @query_params() def pause_auto_follow_pattern(self, name, params=None, headers=None): if name in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'name'.") return self.transport.perform_request( "POST", _make_path("_ccr", "auto_follow", name, "pause"), params=params, headers=headers, ) @query_params() def resume_auto_follow_pattern(self, name, params=None, headers=None): if name in SKIP_IN_PATH: raise ValueError("Empty value passed for a required argument 'name'.") return self.transport.perform_request( "POST", _make_path("_ccr", "auto_follow", name, "resume"), params=params, headers=headers, )

true