hexsha
stringlengths 40
40
| size
int64 4
1.02M
| ext
stringclasses 8
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
209
| max_stars_repo_name
stringlengths 5
121
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
listlengths 1
10
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
209
| max_issues_repo_name
stringlengths 5
121
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
listlengths 1
10
| max_issues_count
int64 1
67k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
209
| max_forks_repo_name
stringlengths 5
121
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
listlengths 1
10
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 4
1.02M
| avg_line_length
float64 1.07
66.1k
| max_line_length
int64 4
266k
| alphanum_fraction
float64 0.01
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ce6c850b3c6bae5c57c3673251b1a4ff0dc96d09 | 6,880 | py | Python | PythonCode/BoxDrawing.py | sirmurphalot/VisualDisturbances | a32ffc607cb888100b6f9382d1cf41933d265a56 | [
"Apache-2.0"
]
| null | null | null | PythonCode/BoxDrawing.py | sirmurphalot/VisualDisturbances | a32ffc607cb888100b6f9382d1cf41933d265a56 | [
"Apache-2.0"
]
| null | null | null | PythonCode/BoxDrawing.py | sirmurphalot/VisualDisturbances | a32ffc607cb888100b6f9382d1cf41933d265a56 | [
"Apache-2.0"
]
| null | null | null | """
Drawing the aggregate box and points between clips for each film.
Author: Alexander Murph
2/14/2018
"""
##########################################################################################################
##########################################################################################################
## Update 9/28: Uploading this to GitHub. If one wishes to recreate these results, they'll need to add ##
## in their own file paths -- these are specific to my directories. Data will NOT be released yet. ##
## When it is I'll update the file paths so these files will work directly from GitHub ##
##########################################################################################################
##########################################################################################################
# Import a library of functions called 'pygame'
import pygame
import csv
# Initialize the game engine
pygame.init()
# Define some colors
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
GREY = (127, 127, 127)
PI = 3.141592653
# Files Names
nick_names = ["../Data/Hulot_Holiday_Averages.csv",
"../Data/Lumiere_Averages.csv",
"../Data/Musketeer_Averages.csv",
"../Data/N_by_NW_Averages.csv",
"../Data/playtime1_Averages.csv",
"../Data/playtime2_Averages.csv"]
names = ["Hulot_Holiday",
"Lumiere_Averages",
"Musketeer_Averages",
"N_by_NW_Averages",
"playtime1_Averages",
"playtime2_Averages"]
film_number = 5
# Opening our data
data_text = nick_names[film_number]
with open(data_text, 'r') as csvfile:
reader = csv.reader(csvfile)
data_list = list(reader)
# Set the height and width of the screen
size = (1280, 720)
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Film Watching Data")
# Loop until the user clicks the close button.
done = False
clock = pygame.time.Clock()
#data_list = [[5, 200, 300, 50, 50]]
# Loop as long as done == False
# while not done:
# for event in pygame.event.get(): # User did something
# if event.type == pygame.QUIT: # If user clicked close
# done = True # Flag that we are done so we exit this loop
# # All drawing code happens after the for loop and but
# # inside the main while not done loop.
screen.fill(WHITE)
#for data_row in data:
for row in data_list:
print(row)
if row[1] == 'Participant_Number':
continue
average_point_x = float(row[2])
average_point_y = float(row[3])
sd_point_x = float(row[4])
sd_point_y = float(row[5])
if row[6] == "1":
color_box = RED
color_triangle = BLUE
else:
color_box = GREEN
color_triangle = BLACK
pygame.draw.polygon(screen, color_triangle, [[average_point_x, average_point_y - 5], \
[average_point_x - 3, average_point_y + 5], [average_point_x + 3, average_point_y + 5]], 2)
pygame.draw.rect(screen, color_box, [average_point_x - sd_point_x, \
average_point_y - sd_point_y, \
2 * sd_point_x, \
2 * sd_point_y], 2)
# Clear the screen and set the screen background
# Creating the upper x-axis
pygame.draw.line(screen, BLACK, [0, 0], [1280, 0], 5)
pygame.draw.line(screen, BLACK, [320, 0], [320, 10], 5)
font = pygame.font.SysFont('Calibri', 25, True, False)
text = font.render("320", True, BLACK)
screen.blit(text, [308, 11])
pygame.draw.line(screen, BLACK, [640, 0], [640, 10], 5)
text = font.render("640", True, BLACK)
screen.blit(text, [618, 11])
pygame.draw.line(screen, BLACK, [960, 0], [960, 10], 5)
text = font.render("960", True, BLACK)
screen.blit(text, [938, 11])
pygame.draw.line(screen, BLACK, [1280, 0], [1280, 10], 5)
text = font.render("1280", True, BLACK)
screen.blit(text, [1230, 11])
# Creating the left-side y-axis
pygame.draw.line(screen, BLACK, [0, 0], [0, 720], 5)
pygame.draw.line(screen, BLACK, [0, 180], [10, 180], 5)
font = pygame.font.SysFont('Calibri', 25, True, False)
text = font.render("180", True, BLACK)
screen.blit(text, [11, 180])
pygame.draw.line(screen, BLACK, [0, 360], [10, 360], 5)
text = font.render("360", True, BLACK)
screen.blit(text, [11, 360])
pygame.draw.line(screen, BLACK, [0, 540], [10, 540], 5)
text = font.render("540", True, BLACK)
screen.blit(text, [11, 540])
pygame.draw.line(screen, BLACK, [0, 720], [10, 720], 5)
text = font.render("720", True, BLACK)
screen.blit(text, [11, 685])
font = pygame.font.SysFont('Calibri', 30, True, False)
text = font.render(names[film_number], True, BLUE)
screen.blit(text, [1000, 600])
font = pygame.font.SysFont('Calibri', 15, True, False)
text = font.render("Clip 1 = ", True, BLACK)
screen.blit(text, [1000, 650])
text = font.render("Blue", True, BLUE)
screen.blit(text, [1055, 650])
text = font.render("Red", True, RED)
screen.blit(text, [1100, 650])
text = font.render("Clip 2 = ", True, BLACK)
screen.blit(text, [1000, 670])
text = font.render("Black", True, BLACK)
screen.blit(text, [1055, 670])
text = font.render("Green", True, GREEN)
screen.blit(text, [1100, 670])
# Draw on the screen several lines from (0,10) to (100,110)
# 5 pixels wide using a loop
#for y_offset in range(0, 100, 10):
# pygame.draw.line(screen, RED, [0, 10 + y_offset], [100, 110 + y_offset], 5)
# Draw a rectangle
#pygame.draw.rect(screen, BLACK, [20, 20, 250, 100], 2)
# Draw an ellipse, using a rectangle as the outside boundaries
#pygame.draw.ellipse(screen, BLACK, [20, 20, 250, 100], 2)
# Draw an arc as part of an ellipse.
# Use radians to determine what angle to draw.
#pygame.draw.arc(screen, BLACK, [20, 220, 250, 200], 0, PI / 2, 2)
#pygame.draw.arc(screen, GREEN, [20, 220, 250, 200], PI / 2, PI, 2)
#pygame.draw.arc(screen, BLUE, [20, 220, 250, 200], PI, 3 * PI / 2, 2)
#pygame.draw.arc(screen, RED, [20, 220, 250, 200], 3 * PI / 2, 2 * PI, 2)
# This draws a triangle using the polygon command
#pygame.draw.polygon(screen, BLACK, [[100, 100], [0, 200], [200, 200]], 5)
# Select the font to use, size, bold, italics
#font = pygame.font.SysFont('Calibri', 25, True, False)
# Render the text. "True" means anti-aliased text.
# Black is the color. This creates an image of the
# letters, but does not put it on the screen
#text = font.render("My text", True, BLACK)
# Put the image of the text on the screen at 250x250
#screen.blit(text, [250, 250])
# Go ahead and update the screen with what we've drawn.
# This MUST happen after all the other drawing commands.
pygame.display.flip()
pygame.image.save(screen, "../Output/BetweenClips/" + names[film_number] + ".jpeg")
# This limits the while loop to a max of 60 times per second.
# Leave this out and we will use all CPU we can.
clock.tick(60)
# Be IDLE friendly
pygame.quit() | 31.851852 | 106 | 0.6125 |
903b73a1feff7174c18e76664e86ccffcca2773f | 2,669 | py | Python | test-suite/generated-src/python/dh__list_map_string_int64_t.py | trafi/trafi-djinni | 47cd2c849782e2ab4b38e5dc6a5a3104cc87f673 | [
"Apache-2.0"
]
| 3 | 2020-12-15T06:44:50.000Z | 2022-01-24T13:27:31.000Z | test-suite/generated-src/python/dh__list_map_string_int64_t.py | trafi/trafi-djinni | 47cd2c849782e2ab4b38e5dc6a5a3104cc87f673 | [
"Apache-2.0"
]
| null | null | null | test-suite/generated-src/python/dh__list_map_string_int64_t.py | trafi/trafi-djinni | 47cd2c849782e2ab4b38e5dc6a5a3104cc87f673 | [
"Apache-2.0"
]
| 2 | 2020-12-01T18:39:26.000Z | 2021-02-04T03:55:31.000Z | # AUTOGENERATED FILE - DO NOT MODIFY!
# This file generated by Djinni from map.djinni
from djinni.support import MultiSet # default imported in all files
from djinni.exception import CPyException # default imported in all files
from djinni.pycffi_marshal import CPyObject, CPyObject, CPyObjectProxy, CPyPrimitive, CPyString
from dh__map_string_int64_t import MapStringInt64THelper
from dh__map_string_int64_t import MapStringInt64TProxy
from PyCFFIlib_cffi import ffi, lib
from djinni import exception # this forces run of __init__.py which gives cpp option to call back into py to create exception
class ListMapStringInt64THelper:
c_data_set = MultiSet()
@staticmethod
def check_c_data_set_empty():
assert len(ListMapStringInt64THelper.c_data_set) == 0
MapStringInt64THelper.check_c_data_set_empty()
@ffi.callback("struct DjinniObjectHandle *(struct DjinniObjectHandle *, size_t)")
def __get_elem(cself, index):
try:
_ret = CPyObjectProxy.fromPy(MapStringInt64THelper.c_data_set, MapStringInt64TProxy(CPyObject.toPy(None, cself)[index]))
assert _ret != ffi.NULL
return _ret
except Exception as _djinni_py_e:
CPyException.setExceptionFromPy(_djinni_py_e)
return ffi.NULL
@ffi.callback("size_t(struct DjinniObjectHandle *)")
def __get_size(cself):
return len(CPyObject.toPy(None, cself))
@ffi.callback("struct DjinniObjectHandle *()")
def __python_create():
c_ptr = ffi.new_handle(list())
ListMapStringInt64THelper.c_data_set.add(c_ptr)
return ffi.cast("struct DjinniObjectHandle *", c_ptr)
@ffi.callback("void(struct DjinniObjectHandle *, struct DjinniObjectHandle *)")
def __python_add(cself, el):
CPyObject.toPy(None, cself).append(CPyObjectProxy.toPyObj(MapStringInt64THelper.c_data_set, el))
@ffi.callback("void(struct DjinniObjectHandle * )")
def __delete(c_ptr):
assert c_ptr in ListMapStringInt64THelper.c_data_set
ListMapStringInt64THelper.c_data_set.remove(c_ptr)
@staticmethod
def _add_callbacks():
lib.list_map_string_int64_t_add_callback__get_elem(ListMapStringInt64THelper.__get_elem)
lib.list_map_string_int64_t_add_callback___delete(ListMapStringInt64THelper.__delete)
lib.list_map_string_int64_t_add_callback__get_size(ListMapStringInt64THelper.__get_size)
lib.list_map_string_int64_t_add_callback__python_create(ListMapStringInt64THelper.__python_create)
lib.list_map_string_int64_t_add_callback__python_add(ListMapStringInt64THelper.__python_add)
ListMapStringInt64THelper._add_callbacks()
| 43.754098 | 132 | 0.766579 |
d526dace33831c195f9fa6e9645d2c3d3ee64615 | 1,956 | py | Python | model-optimizer/extensions/front/caffe/correlation_ext_test.py | JOCh1958/openvino | 070201feeec5550b7cf8ec5a0ffd72dc879750be | [
"Apache-2.0"
]
| 1 | 2021-04-06T03:32:12.000Z | 2021-04-06T03:32:12.000Z | model-optimizer/extensions/front/caffe/correlation_ext_test.py | JOCh1958/openvino | 070201feeec5550b7cf8ec5a0ffd72dc879750be | [
"Apache-2.0"
]
| 28 | 2021-09-24T09:29:02.000Z | 2022-03-28T13:20:46.000Z | model-optimizer/extensions/front/caffe/correlation_ext_test.py | JOCh1958/openvino | 070201feeec5550b7cf8ec5a0ffd72dc879750be | [
"Apache-2.0"
]
| 1 | 2020-08-30T11:48:03.000Z | 2020-08-30T11:48:03.000Z | # Copyright (C) 2018-2021 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import unittest
from unittest.mock import patch
from extensions.front.caffe.correlation_ext import CorrelationFrontExtractor
from extensions.ops.correlation import CorrelationOp
from mo.ops.op import Op
from mo.utils.unittest.extractors import FakeMultiParam
from mo.utils.unittest.graph import FakeNode
class FakeCorrProtoLayer:
def __init__(self, val):
self.correlation_param = val
class TestCorrelationExt(unittest.TestCase):
@classmethod
def setUpClass(cls):
Op.registered_ops['Correlation'] = CorrelationOp
def test_da_no_pb_no_ml(self):
self.assertRaises(AttributeError, CorrelationFrontExtractor.extract, None)
@patch('extensions.front.caffe.correlation_ext.merge_attrs')
def test_resample_ext_ideal_numbers(self, merge_attrs_mock):
params = {
'pad': 20,
'kernel_size': 1,
'max_displacement': 20,
'stride_1': 1,
'stride_2': 2,
'single_direction': 0,
'do_abs': False,
'correlation_type': 'caffe.CorrelationParameter.MULTIPLY'
}
merge_attrs_mock.return_value = {
**params,
'test': 54,
'test2': 'test3'
}
fake_pl = FakeCorrProtoLayer(FakeMultiParam(params))
fake_node = FakeNode(fake_pl, None)
CorrelationFrontExtractor.extract(fake_node)
exp_res = {
'type': "Correlation",
'pad': 20,
'kernel_size': 1,
'max_displacement': 20,
'stride_1': 1,
'stride_2': 2,
'single_direction': 0,
'do_abs': False,
'correlation_type': 'caffe.CorrelationParameter.MULTIPLY',
'infer': CorrelationOp.corr_infer
}
for key in exp_res.keys():
self.assertEqual(fake_node[key], exp_res[key])
| 30.092308 | 82 | 0.629346 |
c74684c93d65269c96058e8403d0f1ace1d3f735 | 4,710 | py | Python | sdk/containerservice/azure-mgmt-containerservice/azure/mgmt/containerservice/v2020_03_01/operations/_operations.py | adewaleo/azure-sdk-for-python | 169457edbea5e3c5557246cfcf8bd635d528bae4 | [
"MIT"
]
| 1 | 2021-09-07T18:35:07.000Z | 2021-09-07T18:35:07.000Z | sdk/containerservice/azure-mgmt-containerservice/azure/mgmt/containerservice/v2020_03_01/operations/_operations.py | adewaleo/azure-sdk-for-python | 169457edbea5e3c5557246cfcf8bd635d528bae4 | [
"MIT"
]
| null | null | null | sdk/containerservice/azure-mgmt-containerservice/azure/mgmt/containerservice/v2020_03_01/operations/_operations.py | adewaleo/azure-sdk-for-python | 169457edbea5e3c5557246cfcf8bd635d528bae4 | [
"MIT"
]
| null | null | null | # coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
from typing import TYPE_CHECKING
import warnings
from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.paging import ItemPaged
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import HttpRequest, HttpResponse
from azure.mgmt.core.exceptions import ARMErrorFormat
from .. import models
if TYPE_CHECKING:
# pylint: disable=unused-import,ungrouped-imports
from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar
T = TypeVar('T')
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
class Operations(object):
"""Operations operations.
You should not instantiate this class directly. Instead, you should create a Client instance that
instantiates it for you and attaches it as an attribute.
:ivar models: Alias to model classes used in this operation group.
:type models: ~azure.mgmt.containerservice.v2020_03_01.models
:param client: Client for service requests.
:param config: Configuration of service client.
:param serializer: An object model serializer.
:param deserializer: An object model deserializer.
"""
models = models
def __init__(self, client, config, serializer, deserializer):
self._client = client
self._serialize = serializer
self._deserialize = deserializer
self._config = config
def list(
self,
**kwargs # type: Any
):
# type: (...) -> Iterable["models.OperationListResult"]
"""Gets a list of compute operations.
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either OperationListResult or the result of cls(response)
:rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.containerservice.v2020_03_01.models.OperationListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["models.OperationListResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2020-03-01"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
request = self._client.get(url, query_parameters, header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters, header_parameters)
return request
def extract_data(pipeline_response):
deserialized = self._deserialize('OperationListResult', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return None, iter(list_of_elem)
def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
return pipeline_response
return ItemPaged(
get_next, extract_data
)
list.metadata = {'url': '/providers/Microsoft.ContainerService/operations'} # type: ignore
| 42.818182 | 133 | 0.655202 |
ec9ee088c990aee214817587fbdd26bd42f1fd59 | 909 | py | Python | config/m600/avionics_sensor.py | leozz37/makani | c94d5c2b600b98002f932e80a313a06b9285cc1b | [
"Apache-2.0"
]
| 1,178 | 2020-09-10T17:15:42.000Z | 2022-03-31T14:59:35.000Z | config/m600/avionics_sensor.py | leozz37/makani | c94d5c2b600b98002f932e80a313a06b9285cc1b | [
"Apache-2.0"
]
| 1 | 2020-05-22T05:22:35.000Z | 2020-05-22T05:22:35.000Z | config/m600/avionics_sensor.py | leozz37/makani | c94d5c2b600b98002f932e80a313a06b9285cc1b | [
"Apache-2.0"
]
| 107 | 2020-09-10T17:29:30.000Z | 2022-03-18T09:00:14.000Z | # Copyright 2020 Makani Technologies LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Avionics sensing parameters."""
from makani.config import mconfig
@mconfig.Config
def MakeParams():
return {
# TODO: These values are out-of-date.
'v_avionics_cal': {'scale': 25.0 / 4096.0, 'bias': 0.0, 'bias_count': 0},
'v_servo_cal': {'scale': 25.0 / 4096.0, 'bias': 0.0, 'bias_count': 0}
}
| 34.961538 | 79 | 0.712871 |
0c08d4dc18d66f3f6aa58df64e4a34fb3f877e62 | 2,822 | py | Python | gifmaker/random_32nodes.py | SPE-MD/SPMD-Simulations | e5d592262ff290e07ffb1664acbfa7eab86b0b55 | [
"MIT"
]
| 3 | 2021-03-27T04:15:40.000Z | 2022-03-21T11:16:36.000Z | gifmaker/random_32nodes.py | SPE-MD/SPMD-Simulations | e5d592262ff290e07ffb1664acbfa7eab86b0b55 | [
"MIT"
]
| null | null | null | gifmaker/random_32nodes.py | SPE-MD/SPMD-Simulations | e5d592262ff290e07ffb1664acbfa7eab86b0b55 | [
"MIT"
]
| 1 | 2021-03-22T16:00:14.000Z | 2021-03-22T16:00:14.000Z | #! /usr/bin/env python3
import sys
import string
import struct
import math
import re
import numpy as np
import argparse
from os.path import dirname
import os.path
sys.path.append(dirname(__file__)) #adds this file's director to the path
import imageio
import subprocess
import shutil
#make the gif file name correspond with the script name
#remove ".py" from script namd and replace it with ".gif"
this_dir = os.getcwd()
gif_file = sys.argv[0][:-3]+".gif"
#remove old gif generation files
if os.path.exists("frames"):
try:
shutil.rmtree("./frames")
except:
print( "Issue removing old files in './frames/'" )
exit(1)
#recreate the directory to hold the gif files
if not os.path.exists("frames"):
try:
os.makedirs("frames")
except:
print( "Cannot create 'frames' folder")
exit(1)
#loop through the sim and build up a library of png images to animate
pngfiles = []
#change the cable length
#for i in range(15,100+1):
# try:
# subprocess.run(["python","cmodel.py"\
# ,"--seed=144704"\
# ,"--nodes=16"\
# ,"--length=%d" % i\
# ,"--separation_min=1"\
# ,"--drop_max=0.5"\
# ,"--noplot"\
# ])
os.chdir("../ADI_Model")
loop=0
#change the drop length
d=0.0
c=30
n=32
t=1
s=0
l=100
#for i in range(15,30+1,1):
#for d in range(0,50,5):
#for d in range(0,50,5):
#for n in range(2,32+1):
#for l in range(16,100):
#for t in range(1,n+1):
for s in range(1,30):
cnode = c * 1e-12
drop = d/100
try:
command = ["python","cmodel.py"\
,"--seed=%d" % s\
,"--nodes=%d" % n\
,"--length=%f" % l\
,"--separation_min=1"\
,"--tx_node=%d" % t\
#,"--start_attach=1"\
#,"--end_attach=1"\
,"--drop_max=%.02f" % drop\
,"--cnode=%.02g" % cnode\
#,"--attach_error=0.1"\
,"--random_attach"\
,"--noplot"\
,"--noautoscale"\
]
print(" ".join(command))
subprocess.run(command)
except:
print( "Issue running simulation" )
exit(1)
try:
new_file = os.path.join(this_dir,"frames","frame_%d.png" % (loop))
shutil.move("zcable.png", new_file)
loop+=1
except Exception as e:
print( e )
print( "Issue copying image file" )
exit(1)
pngfiles.append(new_file)
os.chdir(this_dir)
#setup the gif loop to go forward, then backwards, and loop forever
loop = []
for png in pngfiles:
loop.append(png)
for png in reversed(pngfiles):
loop.append(png)
print("Compiling Gif")
images = []
for filename in loop:
images.append(imageio.imread(filename))
imageio.mimsave(gif_file, images)
print("generated gif: %s" % gif_file)
| 23.714286 | 74 | 0.57158 |
d7907451aa742dce70891c14049e1ae264c028ce | 616 | py | Python | convnet/validate.py | Prayogkarki/prog-eval | 461302a9776c4a5f051469c48d1b4228b604ba4d | [
"MIT"
]
| 4 | 2019-07-16T13:41:59.000Z | 2021-04-09T03:51:26.000Z | convnet/validate.py | Prayogkarki/prog-eval | 461302a9776c4a5f051469c48d1b4228b604ba4d | [
"MIT"
]
| 4 | 2019-07-09T20:28:48.000Z | 2019-09-03T16:32:33.000Z | convnet/validate.py | Prayogkarki/prog-eval | 461302a9776c4a5f051469c48d1b4228b604ba4d | [
"MIT"
]
| 12 | 2019-07-03T19:12:35.000Z | 2020-03-25T18:12:15.000Z | #!/usr/bin/env python
"""
convnet/validate.py
"""
import sys
import json
import numpy as np
ACC_THRESHOLD = 0.95
if __name__ == '__main__':
y_test = np.load('data/cifar2/y_test.npy')
y_pred = np.array([int(xx) for xx in open('results/preds').read().splitlines()])
test_acc = (y_test == y_pred).mean()
# --
# Log
print(json.dumps({
"test_acc" : float(test_acc),
"status" : "PASS" if test_acc >= ACC_THRESHOLD else "FAIL",
}))
does_pass = "PASS" if test_acc >= ACC_THRESHOLD else "FAIL"
open('results/.pass', 'w').write(str(does_pass))
| 21.241379 | 84 | 0.594156 |
858b5fcc5b3e990e8cdea19386bb68377c8019ca | 57 | py | Python | django15_project/my_django15_project/invokerHTMLDOM.py | ijhajj/Django-RestApi-Celery-RabbitMQ-Redis | 4b6fb7f8dd26ccafe4a00fc64b687c7450504a8f | [
"MIT"
]
| null | null | null | django15_project/my_django15_project/invokerHTMLDOM.py | ijhajj/Django-RestApi-Celery-RabbitMQ-Redis | 4b6fb7f8dd26ccafe4a00fc64b687c7450504a8f | [
"MIT"
]
| 4 | 2020-06-05T23:43:38.000Z | 2022-03-02T14:59:34.000Z | django15_project/my_django15_project/invokerHTMLDOM.py | ijhajj/Django-RestApi-Celery-RabbitMQ-Redis | 4b6fb7f8dd26ccafe4a00fc64b687c7450504a8f | [
"MIT"
]
| 1 | 2021-02-10T14:57:52.000Z | 2021-02-10T14:57:52.000Z | from tasks import data_extractor
data_extractor.delay()
| 14.25 | 32 | 0.842105 |
517edbe1b1af68e808c495f3b12b1cedc5060b1f | 683 | py | Python | publiapp_api/migrations/0015_auto_20201024_1703.py | KevinPercy/PubliAppAPI | 262fe66eaf2ac1d895681b0e611f6d7633e2353e | [
"MIT"
]
| null | null | null | publiapp_api/migrations/0015_auto_20201024_1703.py | KevinPercy/PubliAppAPI | 262fe66eaf2ac1d895681b0e611f6d7633e2353e | [
"MIT"
]
| 6 | 2020-06-30T02:38:05.000Z | 2021-09-22T19:21:35.000Z | publiapp_api/migrations/0015_auto_20201024_1703.py | KevinPercy/PubliAppAPI | 262fe66eaf2ac1d895681b0e611f6d7633e2353e | [
"MIT"
]
| null | null | null | # Generated by Django 3.0.7 on 2020-10-24 17:03
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('publiapp_api', '0014_auto_20201004_1752'),
]
operations = [
migrations.RemoveField(
model_name='detalleanuncio',
name='id_categoria',
),
migrations.AddField(
model_name='detalleanuncio',
name='categoria',
field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.CASCADE, related_name='categoria', to='publiapp_api.Categoria'),
preserve_default=False,
),
]
| 27.32 | 147 | 0.635432 |
f80a7991b7fb1c3ef1e9249a42766494dacff883 | 2,667 | py | Python | server/auvsi_suas/models/gps_position_test.py | dcat52/interop | b016b2c25e468e21649bdb7475d828198b5e6958 | [
"Apache-2.0"
]
| null | null | null | server/auvsi_suas/models/gps_position_test.py | dcat52/interop | b016b2c25e468e21649bdb7475d828198b5e6958 | [
"Apache-2.0"
]
| null | null | null | server/auvsi_suas/models/gps_position_test.py | dcat52/interop | b016b2c25e468e21649bdb7475d828198b5e6958 | [
"Apache-2.0"
]
| null | null | null | """Tests for the gps_position model."""
from auvsi_suas.models.gps_position import GpsPosition
from django.test import TestCase
class TestGpsPositionModel(TestCase):
"""Tests the GpsPosition model."""
def test_unicode(self):
"""Tests the unicode method executes."""
pos = GpsPosition(latitude=10, longitude=100)
pos.save()
pos.__unicode__()
def assert_distance_equal(self, pos1, pos2, dist, threshold=10):
"""GpsPosition distances are within threshold (ft)."""
self.assertAlmostEqual(pos1.distance_to(pos2), dist, delta=threshold)
self.assertAlmostEqual(pos2.distance_to(pos1), dist, delta=threshold)
def evaluate_distance_inputs(self, io_list):
"""Evaluates the distance_to calc with the given input list."""
for (lon1, lat1, lon2, lat2, dist_actual) in io_list:
gps1 = GpsPosition(latitude=lat1, longitude=lon1)
gps1.save()
gps2 = GpsPosition(latitude=lat2, longitude=lon2)
gps2.save()
self.assert_distance_equal(gps1, gps2, dist_actual)
def test_distance_zero(self):
"""Tests distance calc for same position."""
self.evaluate_distance_inputs([
# (lon1, lat1, lon2, lat2, dist_actual)
(0, 0, 0, 0, 0),
(1, 1, 1, 1, 0),
(-1, -1, -1, -1, 0),
(1, -1, 1, -1, 0),
(-1, 1, -1, 1, 0),
(76, 42, 76, 42, 0),
(-76, 42, -76, 42, 0),
]) # yapf: disable
def test_distance_competition_amounts(self):
"""Tests distance calc for competition amounts."""
self.evaluate_distance_inputs([
# (lon1, lat1, lon2, lat2, dist_actual)
(-76.428709, 38.145306, -76.426375, 38.146146, 736.4),
(-76.428537, 38.145399, -76.427818, 38.144686, 329.6),
(-76.434261, 38.142471, -76.418876, 38.147838, 4820.0),
]) # yapf: disable
def test_duplicate_unequal(self):
"""Tests the duplicate function for nonequal positions."""
gps1 = GpsPosition(latitude=0, longitude=0)
gps2 = GpsPosition(latitude=1, longitude=0)
gps3 = GpsPosition(latitude=0, longitude=1)
self.assertFalse(gps1.duplicate(gps2))
self.assertFalse(gps1.duplicate(gps3))
def test_duplicate_equal(self):
"""Tests the duplicate function for equal positiions."""
gps1 = GpsPosition(latitude=1, longitude=1)
gps2 = GpsPosition(latitude=1, longitude=1)
self.assertTrue(gps1.duplicate(gps2))
| 38.1 | 77 | 0.587552 |
38eab051222f714e07f185ea7d42f0e14b87e4c8 | 1,082 | py | Python | utils/s3dis_utils/collect_indoor3d_data.py | LaureenK/JSNet_LK | ece95891f17224b59185cc2beeb0512f56248d1e | [
"MIT"
]
| null | null | null | utils/s3dis_utils/collect_indoor3d_data.py | LaureenK/JSNet_LK | ece95891f17224b59185cc2beeb0512f56248d1e | [
"MIT"
]
| null | null | null | utils/s3dis_utils/collect_indoor3d_data.py | LaureenK/JSNet_LK | ece95891f17224b59185cc2beeb0512f56248d1e | [
"MIT"
]
| null | null | null | import os
import sys
FILE_DIR = os.path.dirname(os.path.abspath(__file__))
BASE_DIR = os.path.dirname(os.path.dirname(FILE_DIR))
sys.path.append(BASE_DIR)
from utils import indoor3d_util
anno_paths = [line.rstrip() for line in open(os.path.join(BASE_DIR, 'meta/anno_paths.txt'))]
anno_paths = [os.path.join(indoor3d_util.DATA_PATH, p) for p in anno_paths]
output_folder = os.path.join(BASE_DIR, 'data/stanford_indoor3d_ins.sem')
if not os.path.exists(output_folder):
os.mkdir(output_folder)
# Note: there is an extra character in the v1.2 data in Area_5/hallway_6. It's fixed manually.
for anno_path in anno_paths:
print(anno_path)
try:
elements = anno_path.split('/')
out_filename = elements[-3]+'_'+elements[-2]+'.npy' # Area_1_hallway_1.npy
print(out_filename)
if os.path.exists(os.path.join(output_folder, out_filename)):
continue
print("Try collect_point_label")
indoor3d_util.collect_point_label(anno_path, os.path.join(output_folder, out_filename), 'numpy')
except:
print('ERROR!!')
| 34.903226 | 104 | 0.713494 |
bf7587756b349716473f432e0ea66da521498693 | 66,527 | py | Python | electrumx/lib/coins.py | rootSig/electrumx-atom | c11b36cdf5acdb9129d7d4507a79cdd7d1408bcb | [
"MIT"
]
| null | null | null | electrumx/lib/coins.py | rootSig/electrumx-atom | c11b36cdf5acdb9129d7d4507a79cdd7d1408bcb | [
"MIT"
]
| null | null | null | electrumx/lib/coins.py | rootSig/electrumx-atom | c11b36cdf5acdb9129d7d4507a79cdd7d1408bcb | [
"MIT"
]
| 1 | 2018-09-11T23:55:55.000Z | 2018-09-11T23:55:55.000Z | # Copyright (c) 2016-2017, Neil Booth
# Copyright (c) 2017, the ElectrumX authors
#
# All rights reserved.
#
# The MIT License (MIT)
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
'''Module providing coin abstraction.
Anything coin-specific should go in this file and be subclassed where
necessary for appropriate handling.
'''
from collections import namedtuple
import re
import struct
from decimal import Decimal
from hashlib import sha256
from functools import partial
import base64
import electrumx.lib.util as util
from electrumx.lib.hash import Base58, hash160, double_sha256, hash_to_hex_str
from electrumx.lib.hash import HASHX_LEN
from electrumx.lib.script import ScriptPubKey, OpCodes
import electrumx.lib.tx as lib_tx
import electrumx.server.block_processor as block_proc
import electrumx.server.daemon as daemon
from electrumx.server.session import ElectrumX, DashElectrumX
Block = namedtuple("Block", "raw header transactions")
OP_RETURN = OpCodes.OP_RETURN
class CoinError(Exception):
'''Exception raised for coin-related errors.'''
class Coin(object):
'''Base class of coin hierarchy.'''
REORG_LIMIT = 200
# Not sure if these are coin-specific
RPC_URL_REGEX = re.compile('.+@(\\[[0-9a-fA-F:]+\\]|[^:]+)(:[0-9]+)?')
VALUE_PER_COIN = 100000000
CHUNK_SIZE = 2016
BASIC_HEADER_SIZE = 80
STATIC_BLOCK_HEADERS = True
SESSIONCLS = ElectrumX
DESERIALIZER = lib_tx.Deserializer
DAEMON = daemon.Daemon
BLOCK_PROCESSOR = block_proc.BlockProcessor
HEADER_VALUES = ('version', 'prev_block_hash', 'merkle_root', 'timestamp',
'bits', 'nonce')
HEADER_UNPACK = struct.Struct('< I 32s 32s I I I').unpack_from
MEMPOOL_HISTOGRAM_REFRESH_SECS = 500
XPUB_VERBYTES = bytes('????', 'utf-8')
XPRV_VERBYTES = bytes('????', 'utf-8')
ENCODE_CHECK = Base58.encode_check
DECODE_CHECK = Base58.decode_check
# Peer discovery
PEER_DEFAULT_PORTS = {'t': '50001', 's': '50002'}
PEERS = []
@classmethod
def lookup_coin_class(cls, name, net):
'''Return a coin class given name and network.
Raise an exception if unrecognised.'''
req_attrs = ['TX_COUNT', 'TX_COUNT_HEIGHT', 'TX_PER_BLOCK']
for coin in util.subclasses(Coin):
if (coin.NAME.lower() == name.lower() and
coin.NET.lower() == net.lower()):
coin_req_attrs = req_attrs.copy()
missing = [attr for attr in coin_req_attrs
if not hasattr(coin, attr)]
if missing:
raise CoinError('coin {} missing {} attributes'
.format(name, missing))
return coin
raise CoinError('unknown coin {} and network {} combination'
.format(name, net))
@classmethod
def sanitize_url(cls, url):
# Remove surrounding ws and trailing /s
url = url.strip().rstrip('/')
match = cls.RPC_URL_REGEX.match(url)
if not match:
raise CoinError('invalid daemon URL: "{}"'.format(url))
if match.groups()[1] is None:
url += ':{:d}'.format(cls.RPC_PORT)
if not url.startswith('http://') and not url.startswith('https://'):
url = 'http://' + url
return url + '/'
@classmethod
def genesis_block(cls, block):
'''Check the Genesis block is the right one for this coin.
Return the block less its unspendable coinbase.
'''
header = cls.block_header(block, 0)
header_hex_hash = hash_to_hex_str(cls.header_hash(header))
if header_hex_hash != cls.GENESIS_HASH:
raise CoinError('genesis block has hash {} expected {}'
.format(header_hex_hash, cls.GENESIS_HASH))
return header + bytes(1)
@classmethod
def hashX_from_script(cls, script):
'''Returns a hashX from a script, or None if the script is provably
unspendable so the output can be dropped.
'''
if script and script[0] == OP_RETURN:
return None
return sha256(script).digest()[:HASHX_LEN]
@staticmethod
def lookup_xverbytes(verbytes):
'''Return a (is_xpub, coin_class) pair given xpub/xprv verbytes.'''
# Order means BTC testnet will override NMC testnet
for coin in util.subclasses(Coin):
if verbytes == coin.XPUB_VERBYTES:
return True, coin
if verbytes == coin.XPRV_VERBYTES:
return False, coin
raise CoinError('version bytes unrecognised')
@classmethod
def address_to_hashX(cls, address):
'''Return a hashX given a coin address.'''
return cls.hashX_from_script(cls.pay_to_address_script(address))
@classmethod
def P2PKH_address_from_hash160(cls, hash160):
'''Return a P2PKH address given a public key.'''
assert len(hash160) == 20
return cls.ENCODE_CHECK(cls.P2PKH_VERBYTE + hash160)
@classmethod
def P2PKH_address_from_pubkey(cls, pubkey):
'''Return a coin address given a public key.'''
return cls.P2PKH_address_from_hash160(hash160(pubkey))
@classmethod
def P2SH_address_from_hash160(cls, hash160):
'''Return a coin address given a hash160.'''
assert len(hash160) == 20
return cls.ENCODE_CHECK(cls.P2SH_VERBYTES[0] + hash160)
@classmethod
def hash160_to_P2PKH_script(cls, hash160):
return ScriptPubKey.P2PKH_script(hash160)
@classmethod
def hash160_to_P2PKH_hashX(cls, hash160):
return cls.hashX_from_script(cls.hash160_to_P2PKH_script(hash160))
@classmethod
def pay_to_address_script(cls, address):
'''Return a pubkey script that pays to a pubkey hash.
Pass the address (either P2PKH or P2SH) in base58 form.
'''
raw = cls.DECODE_CHECK(address)
# Require version byte(s) plus hash160.
verbyte = -1
verlen = len(raw) - 20
if verlen > 0:
verbyte, hash160 = raw[:verlen], raw[verlen:]
if verbyte == cls.P2PKH_VERBYTE:
return cls.hash160_to_P2PKH_script(hash160)
if verbyte in cls.P2SH_VERBYTES:
return ScriptPubKey.P2SH_script(hash160)
raise CoinError('invalid address: {}'.format(address))
@classmethod
def privkey_WIF(cls, privkey_bytes, compressed):
'''Return the private key encoded in Wallet Import Format.'''
payload = bytearray(cls.WIF_BYTE) + privkey_bytes
if compressed:
payload.append(0x01)
return cls.ENCODE_CHECK(payload)
@classmethod
def header_hash(cls, header):
'''Given a header return hash'''
return double_sha256(header)
@classmethod
def header_prevhash(cls, header):
'''Given a header return previous hash'''
return header[4:36]
@classmethod
def static_header_offset(cls, height):
'''Given a header height return its offset in the headers file.
If header sizes change at some point, this is the only code
that needs updating.'''
assert cls.STATIC_BLOCK_HEADERS
return height * cls.BASIC_HEADER_SIZE
@classmethod
def static_header_len(cls, height):
'''Given a header height return its length.'''
return (cls.static_header_offset(height + 1)
- cls.static_header_offset(height))
@classmethod
def block_header(cls, block, height):
'''Returns the block header given a block and its height.'''
return block[:cls.static_header_len(height)]
@classmethod
def block(cls, raw_block, height):
'''Return a Block namedtuple given a raw block and its height.'''
header = cls.block_header(raw_block, height)
txs = cls.DESERIALIZER(raw_block, start=len(header)).read_tx_block()
return Block(raw_block, header, txs)
@classmethod
def decimal_value(cls, value):
'''Return the number of standard coin units as a Decimal given a
quantity of smallest units.
For example 1 BTC is returned for 100 million satoshis.
'''
return Decimal(value) / cls.VALUE_PER_COIN
@classmethod
def electrum_header(cls, header, height):
h = dict(zip(cls.HEADER_VALUES, cls.HEADER_UNPACK(header)))
# Add the height that is not present in the header itself
h['block_height'] = height
# Convert bytes to str
h['prev_block_hash'] = hash_to_hex_str(h['prev_block_hash'])
h['merkle_root'] = hash_to_hex_str(h['merkle_root'])
return h
class AuxPowMixin(object):
STATIC_BLOCK_HEADERS = False
DESERIALIZER = lib_tx.DeserializerAuxPow
@classmethod
def header_hash(cls, header):
'''Given a header return hash'''
return double_sha256(header[:cls.BASIC_HEADER_SIZE])
@classmethod
def block_header(cls, block, height):
'''Return the AuxPow block header bytes'''
deserializer = cls.DESERIALIZER(block)
return deserializer.read_header(height, cls.BASIC_HEADER_SIZE)
class EquihashMixin(object):
STATIC_BLOCK_HEADERS = False
BASIC_HEADER_SIZE = 140 # Excluding Equihash solution
DESERIALIZER = lib_tx.DeserializerEquihash
HEADER_VALUES = ('version', 'prev_block_hash', 'merkle_root', 'reserved',
'timestamp', 'bits', 'nonce')
HEADER_UNPACK = struct.Struct('< I 32s 32s 32s I I 32s').unpack_from
@classmethod
def electrum_header(cls, header, height):
h = dict(zip(cls.HEADER_VALUES, cls.HEADER_UNPACK(header)))
# Add the height that is not present in the header itself
h['block_height'] = height
# Convert bytes to str
h['prev_block_hash'] = hash_to_hex_str(h['prev_block_hash'])
h['merkle_root'] = hash_to_hex_str(h['merkle_root'])
h['reserved'] = hash_to_hex_str(h['reserved'])
h['nonce'] = hash_to_hex_str(h['nonce'])
return h
@classmethod
def block_header(cls, block, height):
'''Return the block header bytes'''
deserializer = cls.DESERIALIZER(block)
return deserializer.read_header(height, cls.BASIC_HEADER_SIZE)
class ScryptMixin(object):
DESERIALIZER = lib_tx.DeserializerTxTime
HEADER_HASH = None
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
if cls.HEADER_HASH is None:
import scrypt
cls.HEADER_HASH = lambda x: scrypt.hash(x, x, 1024, 1, 1, 32)
version, = util.unpack_le_uint32_from(header)
if version > 6:
return super().header_hash(header)
else:
return cls.HEADER_HASH(header)
class KomodoMixin(object):
P2PKH_VERBYTE = bytes.fromhex("3C")
P2SH_VERBYTES = [bytes.fromhex("55")]
WIF_BYTE = bytes.fromhex("BC")
GENESIS_HASH = ('027e3758c3a65b12aa1046462b486d0a'
'63bfa1beae327897f56c5cfb7daaae71')
DESERIALIZER = lib_tx.DeserializerZcash
class BitcoinMixin(object):
SHORTNAME = "BTC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("00")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('000000000019d6689c085ae165831e93'
'4ff763ae46a2a6c172b3f1b60a8ce26f')
RPC_PORT = 8332
class HOdlcoin(Coin):
NAME = "HOdlcoin"
SHORTNAME = "HODLC"
NET = "mainnet"
BASIC_HEADER_SIZE = 88
P2PKH_VERBYTE = bytes.fromhex("28")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("a8")
GENESIS_HASH = ('008872e5582924544e5c707ee4b839bb'
'82c28a9e94e917c94b40538d5658c04b')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 258858
TX_COUNT_HEIGHT = 382138
TX_PER_BLOCK = 5
class BitcoinCash(BitcoinMixin, Coin):
NAME = "BitcoinCash"
SHORTNAME = "BCH"
TX_COUNT = 246362688
TX_COUNT_HEIGHT = 511484
TX_PER_BLOCK = 400
PEERS = [
'electroncash.cascharia.com s50002',
'bch.electrumx.cash s t',
'bccarihace4jdcnt.onion t52001 s52002',
'abc1.hsmiths.com t60001 s60002',
'electroncash.checksum0.com s t',
'electrumx-cash.1209k.com s t',
'electrum.leblancnet.us t50011 s50012',
'electroncash.dk s t',
'electrum.imaginary.cash s t',
]
class BitcoinSegwit(BitcoinMixin, Coin):
NAME = "BitcoinSegwit"
DESERIALIZER = lib_tx.DeserializerSegWit
MEMPOOL_HISTOGRAM_REFRESH_SECS = 120
TX_COUNT = 318337769
TX_COUNT_HEIGHT = 524213
TX_PER_BLOCK = 1400
PEERS = [
'btc.smsys.me s995',
'E-X.not.fyi s t',
'elec.luggs.co s443',
'electrum.vom-stausee.de s t',
'electrum3.hachre.de s t',
'electrum.hsmiths.com s t',
'helicarrier.bauerj.eu s t',
'hsmiths4fyqlw5xw.onion s t',
'luggscoqbymhvnkp.onion t80',
'ozahtqwp25chjdjd.onion s t',
'node.arihanc.com s t',
'arihancckjge66iv.onion s t',
]
class BitcoinGold(EquihashMixin, BitcoinMixin, Coin):
CHUNK_SIZE = 252
NAME = "BitcoinGold"
SHORTNAME = "BTG"
FORK_HEIGHT = 491407
P2PKH_VERBYTE = bytes.fromhex("26")
P2SH_VERBYTES = [bytes.fromhex("17")]
DESERIALIZER = lib_tx.DeserializerEquihashSegWit
TX_COUNT = 265026255
TX_COUNT_HEIGHT = 499923
TX_PER_BLOCK = 50
REORG_LIMIT = 1000
RPC_PORT = 8338
PEERS = [
'electrumx-eu.bitcoingold.org s50002 t50001',
'electrumx-us.bitcoingold.org s50002 t50001',
'electrumx-eu.btcgpu.org s50002 t50001',
'electrumx-us.btcgpu.org s50002 t50001'
]
@classmethod
def header_hash(cls, header):
'''Given a header return hash'''
height, = util.unpack_le_uint32_from(header, 68)
if height >= cls.FORK_HEIGHT:
return double_sha256(header)
else:
return double_sha256(header[:68] + header[100:112])
@classmethod
def electrum_header(cls, header, height):
h = super().electrum_header(header, height)
h['reserved'] = hash_to_hex_str(header[72:100])
h['solution'] = hash_to_hex_str(header[140:])
return h
class BitcoinGoldTestnet(BitcoinGold):
FORK_HEIGHT = 1
SHORTNAME = "TBTG"
XPUB_VERBYTES = bytes.fromhex("043587CF")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("6F")
P2SH_VERBYTES = [bytes.fromhex("C4")]
WIF_BYTE = bytes.fromhex("EF")
TX_COUNT = 0
TX_COUNT_HEIGHT = 1
NET = 'testnet'
RPC_PORT = 18338
GENESIS_HASH = ('00000000e0781ebe24b91eedc293adfe'
'a2f557b53ec379e78959de3853e6f9f6')
PEERS = [
'test-node1.bitcoingold.org s50002',
'test-node2.bitcoingold.org s50002',
'test-node3.bitcoingold.org s50002',
'test-node1.btcgpu.org s50002',
'test-node2.btcgpu.org s50002',
'test-node3.btcgpu.org s50002'
]
class BitcoinGoldRegtest(BitcoinGold):
FORK_HEIGHT = 2000
SHORTNAME = "TBTG"
XPUB_VERBYTES = bytes.fromhex("043587CF")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("6F")
P2SH_VERBYTES = [bytes.fromhex("C4")]
WIF_BYTE = bytes.fromhex("EF")
TX_COUNT = 0
TX_COUNT_HEIGHT = 1
NET = 'regtest'
RPC_PORT = 18444
GENESIS_HASH = ('0f9188f13cb7b2c71f2a335e3a4fc328'
'bf5beb436012afca590b1a11466e2206')
PEERS = []
class Emercoin(Coin):
NAME = "Emercoin"
SHORTNAME = "EMC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("21")
P2SH_VERBYTES = [bytes.fromhex("5c")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('00000000bcccd459d036a588d1008fce'
'8da3754b205736f32ddfd35350e84c2d')
TX_COUNT = 217380620
TX_COUNT_HEIGHT = 464000
TX_PER_BLOCK = 1700
VALUE_PER_COIN = 1000000
RPC_PORT = 6662
DESERIALIZER = lib_tx.DeserializerTxTimeAuxPow
PEERS = []
@classmethod
def block_header(cls, block, height):
'''Returns the block header given a block and its height.'''
deserializer = cls.DESERIALIZER(block)
if deserializer.is_merged_block():
return deserializer.read_header(height, cls.BASIC_HEADER_SIZE)
return block[:cls.static_header_len(height)]
@classmethod
def header_hash(cls, header):
'''Given a header return hash'''
return double_sha256(header[:cls.BASIC_HEADER_SIZE])
class BitcoinTestnetMixin(object):
SHORTNAME = "XTN"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587cf")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("6f")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ef")
GENESIS_HASH = ('000000000933ea01ad0ee984209779ba'
'aec3ced90fa3f408719526f8d77f4943')
REORG_LIMIT = 8000
TX_COUNT = 12242438
TX_COUNT_HEIGHT = 1035428
TX_PER_BLOCK = 21
RPC_PORT = 18332
PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'}
class BitcoinCashTestnet(BitcoinTestnetMixin, Coin):
'''Bitcoin Testnet for Bitcoin Cash daemons.'''
NAME = "BitcoinCash"
PEERS = [
'electrum-testnet-abc.criptolayer.net s50112',
'bchtestnet.arihanc.com t53001 s53002',
'ciiattqkgzebpp6jofjbrkhvhwmgnsfoayljdcrve2p3qmkbv3duaoyd.onion '
't53001 s53002',
]
class BitcoinCashRegtest(BitcoinCashTestnet):
NET = "regtest"
GENESIS_HASH = ('0f9188f13cb7b2c71f2a335e3a4fc328'
'bf5beb436012afca590b1a11466e2206')
PEERS = []
TX_COUNT = 1
TX_COUNT_HEIGHT = 1
class BitcoinSegwitTestnet(BitcoinTestnetMixin, Coin):
'''Bitcoin Testnet for Core bitcoind >= 0.13.1.'''
NAME = "BitcoinSegwit"
DESERIALIZER = lib_tx.DeserializerSegWit
PEERS = [
'electrum.akinbo.org s t',
'he36kyperp3kbuxu.onion s t',
'testnet.hsmiths.com t53011 s53012',
'hsmithsxurybd7uh.onion t53011 s53012',
'testnetnode.arihanc.com s t',
'w3e2orjpiiv2qwem3dw66d7c4krink4nhttngkylglpqe5r22n6n5wid.onion s t',
'testnet.qtornado.com s t',
]
class BitcoinSegwitRegtest(BitcoinSegwitTestnet):
NAME = "BitcoinSegwit"
NET = "regtest"
GENESIS_HASH = ('0f9188f13cb7b2c71f2a335e3a4fc328'
'bf5beb436012afca590b1a11466e2206')
PEERS = []
TX_COUNT = 1
TX_COUNT_HEIGHT = 1
class BitcoinNolnet(BitcoinCash):
'''Bitcoin Unlimited nolimit testnet.'''
NET = "nolnet"
GENESIS_HASH = ('0000000057e31bd2066c939a63b7b862'
'3bd0f10d8c001304bdfc1a7902ae6d35')
PEERS = []
REORG_LIMIT = 8000
TX_COUNT = 583589
TX_COUNT_HEIGHT = 8617
TX_PER_BLOCK = 50
RPC_PORT = 28332
PEER_DEFAULT_PORTS = {'t': '52001', 's': '52002'}
class Litecoin(Coin):
NAME = "Litecoin"
SHORTNAME = "LTC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("30")
P2SH_VERBYTES = [bytes.fromhex("32"), bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("b0")
GENESIS_HASH = ('12a765e31ffd4059bada1e25190f6e98'
'c99d9714d334efa41a195a7e7e04bfe2')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 8908766
TX_COUNT_HEIGHT = 1105256
TX_PER_BLOCK = 10
RPC_PORT = 9332
REORG_LIMIT = 800
PEERS = [
'elec.luggs.co s444',
'electrum-ltc.bysh.me s t',
'electrum-ltc.ddns.net s t',
'electrum-ltc.wilv.in s t',
'electrum.cryptomachine.com p1000 s t',
'electrum.ltc.xurious.com s t',
'eywr5eubdbbe2laq.onion s50008 t50007',
]
class LitecoinTestnet(Litecoin):
SHORTNAME = "XLT"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587cf")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("6f")
P2SH_VERBYTES = [bytes.fromhex("3a"), bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ef")
GENESIS_HASH = ('4966625a4b2851d9fdee139e56211a0d'
'88575f59ed816ff5e6a63deb4e3e29a0')
TX_COUNT = 21772
TX_COUNT_HEIGHT = 20800
TX_PER_BLOCK = 2
RPC_PORT = 19332
REORG_LIMIT = 4000
PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'}
PEERS = [
'electrum-ltc.bysh.me s t',
'electrum.ltc.xurious.com s t',
]
class Viacoin(AuxPowMixin, Coin):
NAME = "Viacoin"
SHORTNAME = "VIA"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("47")
P2SH_VERBYTES = [bytes.fromhex("21")]
WIF_BYTE = bytes.fromhex("c7")
GENESIS_HASH = ('4e9b54001f9976049830128ec0331515'
'eaabe35a70970d79971da1539a400ba1')
TX_COUNT = 113638
TX_COUNT_HEIGHT = 3473674
TX_PER_BLOCK = 30
RPC_PORT = 5222
REORG_LIMIT = 5000
DESERIALIZER = lib_tx.DeserializerAuxPowSegWit
PEERS = [
'vialectrum.bitops.me s t',
'server.vialectrum.org s t',
'vialectrum.viacoin.net s t',
'viax1.bitops.me s t',
]
class ViacoinTestnet(Viacoin):
SHORTNAME = "TVI"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("7f")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ff")
GENESIS_HASH = ('00000007199508e34a9ff81e6ec0c477'
'a4cccff2a4767a8eee39c11db367b008')
RPC_PORT = 25222
REORG_LIMIT = 2500
PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'}
PEERS = [
'vialectrum.bysh.me s t',
]
class ViacoinTestnetSegWit(ViacoinTestnet):
NET = "testnet-segwit"
DESERIALIZER = lib_tx.DeserializerSegWit
# Source: namecoin.org
class Namecoin(AuxPowMixin, Coin):
NAME = "Namecoin"
SHORTNAME = "NMC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("d7dd6370")
XPRV_VERBYTES = bytes.fromhex("d7dc6e31")
P2PKH_VERBYTE = bytes.fromhex("34")
P2SH_VERBYTES = [bytes.fromhex("0d")]
WIF_BYTE = bytes.fromhex("e4")
GENESIS_HASH = ('000000000062b72c5e2ceb45fbc8587e'
'807c155b0da735e6483dfba2f0a9c770')
TX_COUNT = 4415768
TX_COUNT_HEIGHT = 329065
TX_PER_BLOCK = 10
PEERS = [
'elec.luggs.co s446',
]
class NamecoinTestnet(Namecoin):
NAME = "Namecoin"
SHORTNAME = "XNM"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("6f")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ef")
GENESIS_HASH = ('00000007199508e34a9ff81e6ec0c477'
'a4cccff2a4767a8eee39c11db367b008')
class Dogecoin(AuxPowMixin, Coin):
NAME = "Dogecoin"
SHORTNAME = "DOGE"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("02facafd")
XPRV_VERBYTES = bytes.fromhex("02fac398")
P2PKH_VERBYTE = bytes.fromhex("1e")
P2SH_VERBYTES = [bytes.fromhex("16")]
WIF_BYTE = bytes.fromhex("9e")
GENESIS_HASH = ('1a91e3dace36e2be3bf030a65679fe82'
'1aa1d6ef92e7c9902eb318182c355691')
TX_COUNT = 27583427
TX_COUNT_HEIGHT = 1604979
TX_PER_BLOCK = 20
REORG_LIMIT = 2000
class DogecoinTestnet(Dogecoin):
NAME = "Dogecoin"
SHORTNAME = "XDT"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("71")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("f1")
GENESIS_HASH = ('bb0a78264637406b6360aad926284d54'
'4d7049f45189db5664f3c4d07350559e')
# Source: https://github.com/motioncrypto/motion
class Motion(Coin):
NAME = "Motion"
SHORTNAME = "XMN"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488B21E")
XPRV_VERBYTES = bytes.fromhex("0488ADE4")
GENESIS_HASH = ('000001e9dc60dd2618e91f7b90141349'
'22c374496b61c1a272519b1c39979d78')
P2PKH_VERBYTE = bytes.fromhex("32")
P2SH_VERBYTES = [bytes.fromhex("12")]
WIF_BYTE = bytes.fromhex("80")
TX_COUNT_HEIGHT = 54353
TX_COUNT = 92701
TX_PER_BLOCK = 4
RPC_PORT = 3385
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import x16r_hash
return x16r_hash.getPoWHash(header)
# Source: https://github.com/dashpay/dash
class Dash(Coin):
NAME = "Dash"
SHORTNAME = "DASH"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("02fe52cc")
XPRV_VERBYTES = bytes.fromhex("02fe52f8")
GENESIS_HASH = ('00000ffd590b1485b3caadc19b22e637'
'9c733355108f107a430458cdf3407ab6')
P2PKH_VERBYTE = bytes.fromhex("4c")
P2SH_VERBYTES = [bytes.fromhex("10")]
WIF_BYTE = bytes.fromhex("cc")
TX_COUNT_HEIGHT = 569399
TX_COUNT = 2157510
TX_PER_BLOCK = 4
RPC_PORT = 9998
PEERS = [
'electrum.dash.org s t',
'electrum.masternode.io s t',
'electrum-drk.club s t',
'dashcrypto.space s t',
'electrum.dash.siampm.com s t',
'wl4sfwq2hwxnodof.onion s t',
]
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import x11_hash
return x11_hash.getPoWHash(header)
class DashTestnet(Dash):
SHORTNAME = "tDASH"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("3a805837")
XPRV_VERBYTES = bytes.fromhex("3a8061a0")
GENESIS_HASH = ('00000bafbc94add76cb75e2ec9289483'
'7288a481e5c005f6563d91623bf8bc2c')
P2PKH_VERBYTE = bytes.fromhex("8c")
P2SH_VERBYTES = [bytes.fromhex("13")]
WIF_BYTE = bytes.fromhex("ef")
TX_COUNT_HEIGHT = 101619
TX_COUNT = 132681
TX_PER_BLOCK = 1
RPC_PORT = 19998
PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'}
PEERS = [
'electrum.dash.siampm.com s t',
'dasht.random.re s54002 t54001',
]
class Argentum(AuxPowMixin, Coin):
NAME = "Argentum"
SHORTNAME = "ARG"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("17")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("97")
GENESIS_HASH = ('88c667bc63167685e4e4da058fffdfe8'
'e007e5abffd6855de52ad59df7bb0bb2')
TX_COUNT = 2263089
TX_COUNT_HEIGHT = 2050260
TX_PER_BLOCK = 2000
RPC_PORT = 13581
class ArgentumTestnet(Argentum):
SHORTNAME = "XRG"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("6f")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ef")
REORG_LIMIT = 2000
class DigiByte(Coin):
NAME = "DigiByte"
SHORTNAME = "DGB"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("1E")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('7497ea1b465eb39f1c8f507bc877078f'
'e016d6fcb6dfad3a64c98dcc6e1e8496')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 1046018
TX_COUNT_HEIGHT = 1435000
TX_PER_BLOCK = 1000
RPC_PORT = 12022
class DigiByteTestnet(DigiByte):
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("6f")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ef")
GENESIS_HASH = ('b5dca8039e300198e5fe7cd23bdd1728'
'e2a444af34c447dbd0916fa3430a68c2')
RPC_PORT = 15022
REORG_LIMIT = 2000
class FairCoin(Coin):
NAME = "FairCoin"
SHORTNAME = "FAIR"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("5f")
P2SH_VERBYTES = [bytes.fromhex("24")]
WIF_BYTE = bytes.fromhex("df")
GENESIS_HASH = ('beed44fa5e96150d95d56ebd5d262578'
'1825a9407a5215dd7eda723373a0a1d7')
BASIC_HEADER_SIZE = 108
HEADER_VALUES = ('version', 'prev_block_hash', 'merkle_root',
'payload_hash', 'timestamp', 'creatorId')
HEADER_UNPACK = struct.Struct('< I 32s 32s 32s I I').unpack_from
TX_COUNT = 505
TX_COUNT_HEIGHT = 470
TX_PER_BLOCK = 1
RPC_PORT = 40405
PEER_DEFAULT_PORTS = {'t': '51811', 's': '51812'}
PEERS = [
'electrum.faircoin.world s',
'electrumfair.punto0.org s',
]
@classmethod
def block(cls, raw_block, height):
'''Return a Block namedtuple given a raw block and its height.'''
if height > 0:
return super().block(raw_block, height)
else:
return Block(raw_block, cls.block_header(raw_block, height), [])
@classmethod
def electrum_header(cls, header, height):
h = super().electrum_header(header, height)
h['payload_hash'] = hash_to_hex_str(h['payload_hash'])
return h
class Zcash(EquihashMixin, Coin):
NAME = "Zcash"
SHORTNAME = "ZEC"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("1CB8")
P2SH_VERBYTES = [bytes.fromhex("1CBD")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('00040fe8ec8471911baa1db1266ea15d'
'd06b4a8a5c453883c000b031973dce08')
DESERIALIZER = lib_tx.DeserializerZcash
TX_COUNT = 329196
TX_COUNT_HEIGHT = 68379
TX_PER_BLOCK = 5
RPC_PORT = 8232
REORG_LIMIT = 800
class ZcashTestnet(Zcash):
SHORTNAME = "TAZ"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("1D25")
P2SH_VERBYTES = [bytes.fromhex("1CBA")]
WIF_BYTE = bytes.fromhex("EF")
GENESIS_HASH = ('05a60a92d99d85997cce3b87616c089f'
'6124d7342af37106edc76126334a2c38')
TX_COUNT = 242312
TX_COUNT_HEIGHT = 321685
TX_PER_BLOCK = 2
RPC_PORT = 18232
class SnowGem(EquihashMixin, Coin):
NAME = "SnowGem"
SHORTNAME = "SNG"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("1C28")
P2SH_VERBYTES = [bytes.fromhex("1C2D")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('00068b35729d9d2b0c294ff1fe9af009'
'4740524311a131de40e7f705e4c29a5b')
DESERIALIZER = lib_tx.DeserializerZcash
TX_COUNT = 140698
TX_COUNT_HEIGHT = 102802
TX_PER_BLOCK = 2
RPC_PORT = 16112
REORG_LIMIT = 800
CHUNK_SIZE = 200
@classmethod
def electrum_header(cls, header, height):
h = super().electrum_header(header, height)
h['n_solution'] = base64.b64encode(lib_tx.Deserializer(
header, start=140)._read_varbytes()).decode('utf8')
return h
class BitcoinZ(EquihashMixin, Coin):
NAME = "BitcoinZ"
SHORTNAME = "BTCZ"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("1CB8")
P2SH_VERBYTES = [bytes.fromhex("1CBD")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('f499ee3d498b4298ac6a64205b8addb7'
'c43197e2a660229be65db8a4534d75c1')
DESERIALIZER = lib_tx.DeserializerZcash
TX_COUNT = 171976
TX_COUNT_HEIGHT = 81323
TX_PER_BLOCK = 3
RPC_PORT = 1979
REORG_LIMIT = 800
class Hush(EquihashMixin, Coin):
NAME = "Hush"
SHORTNAME = "HUSH"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("1CB8")
P2SH_VERBYTES = [bytes.fromhex("1CBD")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('0003a67bc26fe564b75daf11186d3606'
'52eb435a35ba3d9d3e7e5d5f8e62dc17')
DESERIALIZER = lib_tx.DeserializerZcash
TX_COUNT = 329196
TX_COUNT_HEIGHT = 68379
TX_PER_BLOCK = 5
RPC_PORT = 8822
REORG_LIMIT = 800
class Zclassic(EquihashMixin, Coin):
NAME = "Zclassic"
SHORTNAME = "ZCL"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("1CB8")
P2SH_VERBYTES = [bytes.fromhex("1CBD")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('0007104ccda289427919efc39dc9e4d4'
'99804b7bebc22df55f8b834301260602')
DESERIALIZER = lib_tx.DeserializerZcash
TX_COUNT = 329196
TX_COUNT_HEIGHT = 68379
TX_PER_BLOCK = 5
RPC_PORT = 8023
REORG_LIMIT = 800
class Koto(Coin):
NAME = "Koto"
SHORTNAME = "KOTO"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("1836")
P2SH_VERBYTES = [bytes.fromhex("183B")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('6d424c350729ae633275d51dc3496e16'
'cd1b1d195c164da00f39c499a2e9959e')
DESERIALIZER = lib_tx.DeserializerZcash
TX_COUNT = 158914
TX_COUNT_HEIGHT = 67574
TX_PER_BLOCK = 3
RPC_PORT = 8432
REORG_LIMIT = 800
PEERS = [
'fr.kotocoin.info s t',
'electrum.kotocoin.info s t',
]
class KotoTestnet(Koto):
SHORTNAME = "TOKO"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("18A4")
P2SH_VERBYTES = [bytes.fromhex("1839")]
WIF_BYTE = bytes.fromhex("EF")
GENESIS_HASH = ('bf84afbde20c2d213b68b231ddb585ab'
'616ef7567226820f00d9b397d774d2f0')
TX_COUNT = 91144
TX_COUNT_HEIGHT = 89662
TX_PER_BLOCK = 1
RPC_PORT = 18432
PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'}
PEERS = [
'testnet.kotocoin.info s t',
]
class Komodo(KomodoMixin, EquihashMixin, Coin):
NAME = "Komodo"
SHORTNAME = "KMD"
NET = "mainnet"
TX_COUNT = 693629
TX_COUNT_HEIGHT = 491777
TX_PER_BLOCK = 2
RPC_PORT = 7771
REORG_LIMIT = 800
PEERS = []
class Monaize(KomodoMixin, EquihashMixin, Coin):
NAME = "Monaize"
SHORTNAME = "MNZ"
NET = "mainnet"
TX_COUNT = 256
TX_COUNT_HEIGHT = 128
TX_PER_BLOCK = 2
RPC_PORT = 14337
REORG_LIMIT = 800
PEERS = []
class Einsteinium(Coin):
NAME = "Einsteinium"
SHORTNAME = "EMC2"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("21")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("b0")
GENESIS_HASH = ('4e56204bb7b8ac06f860ff1c845f03f9'
'84303b5b97eb7b42868f714611aed94b')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 2087559
TX_COUNT_HEIGHT = 1358517
TX_PER_BLOCK = 2
RPC_PORT = 41879
REORG_LIMIT = 2000
class Blackcoin(ScryptMixin, Coin):
NAME = "Blackcoin"
SHORTNAME = "BLK"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("19")
P2SH_VERBYTES = [bytes.fromhex("55")]
WIF_BYTE = bytes.fromhex("99")
GENESIS_HASH = ('000001faef25dec4fbcf906e6242621d'
'f2c183bf232f263d0ba5b101911e4563')
DAEMON = daemon.LegacyRPCDaemon
TX_COUNT = 4594999
TX_COUNT_HEIGHT = 1667070
TX_PER_BLOCK = 3
RPC_PORT = 15715
REORG_LIMIT = 5000
class Bitbay(ScryptMixin, Coin):
NAME = "Bitbay"
SHORTNAME = "BAY"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("19")
P2SH_VERBYTES = [bytes.fromhex("55")]
WIF_BYTE = bytes.fromhex("99")
GENESIS_HASH = ('0000075685d3be1f253ce777174b1594'
'354e79954d2a32a6f77fe9cba00e6467')
TX_COUNT = 4594999
TX_COUNT_HEIGHT = 1667070
TX_PER_BLOCK = 3
RPC_PORT = 19914
REORG_LIMIT = 5000
class Peercoin(Coin):
NAME = "Peercoin"
SHORTNAME = "PPC"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("37")
P2SH_VERBYTES = [bytes.fromhex("75")]
WIF_BYTE = bytes.fromhex("b7")
GENESIS_HASH = ('0000000032fe677166d54963b62a4677'
'd8957e87c508eaa4fd7eb1c880cd27e3')
DESERIALIZER = lib_tx.DeserializerTxTime
DAEMON = daemon.LegacyRPCDaemon
TX_COUNT = 1207356
TX_COUNT_HEIGHT = 306425
TX_PER_BLOCK = 4
RPC_PORT = 9902
REORG_LIMIT = 5000
class Reddcoin(Coin):
NAME = "Reddcoin"
SHORTNAME = "RDD"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("3d")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("bd")
GENESIS_HASH = ('b868e0d95a3c3c0e0dadc67ee587aaf9'
'dc8acbf99e3b4b3110fad4eb74c1decc')
DESERIALIZER = lib_tx.DeserializerReddcoin
TX_COUNT = 5413508
TX_COUNT_HEIGHT = 1717382
TX_PER_BLOCK = 3
RPC_PORT = 45443
class Vertcoin(Coin):
NAME = "Vertcoin"
SHORTNAME = "VTC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488B21E")
XPRV_VERBYTES = bytes.fromhex("0488ADE4")
P2PKH_VERBYTE = bytes.fromhex("47")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('4d96a915f49d40b1e5c2844d1ee2dccb'
'90013a990ccea12c492d22110489f0c4')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 2383423
TX_COUNT_HEIGHT = 759076
TX_PER_BLOCK = 3
RPC_PORT = 5888
REORG_LIMIT = 1000
class Monacoin(Coin):
NAME = "Monacoin"
SHORTNAME = "MONA"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488B21E")
XPRV_VERBYTES = bytes.fromhex("0488ADE4")
P2PKH_VERBYTE = bytes.fromhex("32")
P2SH_VERBYTES = [bytes.fromhex("37"), bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("B0")
GENESIS_HASH = ('ff9f1c0116d19de7c9963845e129f9ed'
'1bfc0b376eb54fd7afa42e0d418c8bb6')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 2568580
TX_COUNT_HEIGHT = 1029766
TX_PER_BLOCK = 2
RPC_PORT = 9402
REORG_LIMIT = 1000
PEERS = [
'electrumx.tamami-foundation.org s t',
'electrumx2.tamami-foundation.org s t',
'electrumx3.tamami-foundation.org s t',
'electrumx1.monacoin.nl s t',
'electrumx2.monacoin.nl s t',
'electrumx1.monacoin.ninja s t',
'electrumx2.monacoin.ninja s t',
'electrumx2.movsign.info s t',
'electrum-mona.bitbank.cc s t',
'ri7rzlmdaf4eqbza.onion s t',
]
class MonacoinTestnet(Monacoin):
SHORTNAME = "XMN"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587CF")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("6F")
P2SH_VERBYTES = [bytes.fromhex("75"), bytes.fromhex("C4")]
WIF_BYTE = bytes.fromhex("EF")
GENESIS_HASH = ('a2b106ceba3be0c6d097b2a6a6aacf9d'
'638ba8258ae478158f449c321061e0b2')
TX_COUNT = 83602
TX_COUNT_HEIGHT = 83252
TX_PER_BLOCK = 1
RPC_PORT = 19402
REORG_LIMIT = 1000
PEER_DEFAULT_PORTS = {'t': '51001', 's': '51002'}
PEERS = [
'electrumx1.testnet.monacoin.ninja s t',
'electrumx1.testnet.monacoin.nl s t',
]
class Crown(AuxPowMixin, Coin):
NAME = "Crown"
SHORTNAME = "CRW"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("00")
P2SH_VERBYTES = [bytes.fromhex("1c")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('0000000085370d5e122f64f4ab19c686'
'14ff3df78c8d13cb814fd7e69a1dc6da')
TX_COUNT = 13336629
TX_COUNT_HEIGHT = 1268206
TX_PER_BLOCK = 10
RPC_PORT = 9341
REORG_LIMIT = 1000
PEERS = [
'sgp-crwseed.crowndns.info s t',
'blr-crwseed.crowndns.info s t',
'sfo-crwseed.crowndns.info s t',
'nyc-crwseed.crowndns.info s t',
'ams-crwseed.crowndns.info s t',
'tor-crwseed.crowndns.info s t',
'lon-crwseed.crowndns.info s t',
'fra-crwseed.crowndns.info s t',
]
class Fujicoin(Coin):
NAME = "Fujicoin"
SHORTNAME = "FJC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("24")
P2SH_VERBYTES = [bytes.fromhex("10")]
WIF_BYTE = bytes.fromhex("a4")
GENESIS_HASH = ('adb6d9cfd74075e7f91608add4bd2a2e'
'a636f70856183086842667a1597714a0')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 170478
TX_COUNT_HEIGHT = 1521676
TX_PER_BLOCK = 1
RPC_PORT = 3776
REORG_LIMIT = 1000
class Neblio(ScryptMixin, Coin):
NAME = "Neblio"
SHORTNAME = "NEBL"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("35")
P2SH_VERBYTES = [bytes.fromhex("70")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('7286972be4dbc1463d256049b7471c25'
'2e6557e222cab9be73181d359cd28bcc')
TX_COUNT = 23675
TX_COUNT_HEIGHT = 22785
TX_PER_BLOCK = 1
RPC_PORT = 6326
REORG_LIMIT = 1000
class Bitzeny(Coin):
NAME = "Bitzeny"
SHORTNAME = "ZNY"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("51")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('000009f7e55e9e3b4781e22bd87a7cfa'
'4acada9e4340d43ca738bf4e9fb8f5ce')
ESTIMATE_FEE = 0.001
RELAY_FEE = 0.001
DAEMON = daemon.FakeEstimateFeeDaemon
TX_COUNT = 1408733
TX_COUNT_HEIGHT = 1015115
TX_PER_BLOCK = 1
RPC_PORT = 9252
REORG_LIMIT = 1000
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import zny_yescrypt
return zny_yescrypt.getPoWHash(header)
class CanadaeCoin(AuxPowMixin, Coin):
NAME = "CanadaeCoin"
SHORTNAME = "CDN"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("1C")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("9c")
GENESIS_HASH = ('863626dadaef221e2e2f30ff3dacae44'
'cabdae9e0028058072181b3fb675d94a')
ESTIMATE_FEE = 0.0001
RELAY_FEE = 0.0001
DAEMON = daemon.FakeEstimateFeeDaemon
TX_COUNT = 3455905
TX_COUNT_HEIGHT = 3645419
TX_PER_BLOCK = 1
RPC_PORT = 34330
REORG_LIMIT = 1000
class Denarius(Coin):
NAME = "Denarius"
SHORTNAME = "DNR"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("1E") # Address starts with a D
P2SH_VERBYTES = [bytes.fromhex("5A")]
WIF_BYTE = bytes.fromhex("9E") # WIF starts with a 6
GENESIS_HASH = ('00000d5dbbda01621cfc16bbc1f9bf32'
'64d641a5dbf0de89fd0182c2c4828fcd')
DESERIALIZER = lib_tx.DeserializerTxTime
TX_COUNT = 4230
RPC_PORT = 32339
ESTIMATE_FEE = 0.00001
RELAY_FEE = 0.00001
DAEMON = daemon.FakeEstimateFeeDaemon
TX_COUNT_HEIGHT = 306187
TX_PER_BLOCK = 4000
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import tribus_hash
return tribus_hash.getPoWHash(header)
class DenariusTestnet(Denarius):
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587cf")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("12")
P2SH_VERBYTES = [bytes.fromhex("74")]
WIF_BYTE = bytes.fromhex("ef")
GENESIS_HASH = ('000086bfe8264d241f7f8e5393f74778'
'4b8ca2aa98bdd066278d590462a4fdb4')
RPC_PORT = 32338
REORG_LIMIT = 2000
class Sibcoin(Dash):
NAME = "Sibcoin"
SHORTNAME = "SIB"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("3F")
P2SH_VERBYTES = [bytes.fromhex("28")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('00000c492bf73490420868bc577680bf'
'c4c60116e7e85343bc624787c21efa4c')
DAEMON = daemon.DashDaemon
TX_COUNT = 1000
TX_COUNT_HEIGHT = 10000
TX_PER_BLOCK = 1
RPC_PORT = 1944
REORG_LIMIT = 1000
PEERS = []
@classmethod
def header_hash(cls, header):
'''
Given a header return the hash for sibcoin.
Need to download `x11_gost_hash` module
Source code: https://github.com/ivansib/x11_gost_hash
'''
import x11_gost_hash
return x11_gost_hash.getPoWHash(header)
class Chips(Coin):
NAME = "Chips"
SHORTNAME = "CHIPS"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("3c")
P2SH_VERBYTES = [bytes.fromhex("55")]
WIF_BYTE = bytes.fromhex("bc")
GENESIS_HASH = ('0000006e75f6aa0efdbf7db03132aa4e'
'4d0c84951537a6f5a7c39a0a9d30e1e7')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 145290
TX_COUNT_HEIGHT = 318637
TX_PER_BLOCK = 2
RPC_PORT = 57776
REORG_LIMIT = 800
class Feathercoin(Coin):
NAME = "Feathercoin"
SHORTNAME = "FTC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488BC26")
XPRV_VERBYTES = bytes.fromhex("0488DAEE")
P2PKH_VERBYTE = bytes.fromhex("0E")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("8E")
GENESIS_HASH = ('12a765e31ffd4059bada1e25190f6e98'
'c99d9714d334efa41a195a7e7e04bfe2')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 3170843
TX_COUNT_HEIGHT = 1981777
TX_PER_BLOCK = 2
RPC_PORT = 9337
REORG_LIMIT = 2000
PEERS = [
'electrumx-ch-1.feathercoin.ch s t',
]
class UFO(Coin):
NAME = "UniformFiscalObject"
SHORTNAME = "UFO"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488B21E")
XPRV_VERBYTES = bytes.fromhex("0488ADE4")
P2PKH_VERBYTE = bytes.fromhex("1B")
P2SH_VERBYTES = [bytes.fromhex("44")]
WIF_BYTE = bytes.fromhex("9B")
GENESIS_HASH = ('ba1d39b4928ab03d813d952daf65fb77'
'97fcf538a9c1b8274f4edc8557722d13')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 1608926
TX_COUNT_HEIGHT = 1300154
TX_PER_BLOCK = 2
RPC_PORT = 9888
REORG_LIMIT = 2000
PEERS = [
'electrumx1.ufobject.com s t',
]
class Newyorkcoin(AuxPowMixin, Coin):
NAME = "Newyorkcoin"
SHORTNAME = "NYC"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("3c")
P2SH_VERBYTES = [bytes.fromhex("16")]
WIF_BYTE = bytes.fromhex("bc")
GENESIS_HASH = ('5597f25c062a3038c7fd815fe46c67de'
'dfcb3c839fbc8e01ed4044540d08fe48')
DAEMON = daemon.LegacyRPCDaemon
TX_COUNT = 5161944
TX_COUNT_HEIGHT = 3948743
TX_PER_BLOCK = 2
REORG_LIMIT = 2000
class NewyorkcoinTestnet(Newyorkcoin):
SHORTNAME = "tNYC"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("71")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("f1")
GENESIS_HASH = ('24463e4d3c625b0a9059f309044c2cf0'
'd7e196cf2a6ecce901f24f681be33c8f')
DAEMON = daemon.LegacyRPCDaemon
TX_COUNT = 5161944
TX_COUNT_HEIGHT = 3948743
TX_PER_BLOCK = 2
REORG_LIMIT = 2000
class Bitcore(BitcoinMixin, Coin):
NAME = "Bitcore"
SHORTNAME = "BTX"
P2PKH_VERBYTE = bytes.fromhex("03")
P2SH_VERBYTES = [bytes.fromhex("7D")]
WIF_BYTE = bytes.fromhex("80")
DESERIALIZER = lib_tx.DeserializerSegWit
GENESIS_HASH = ('604148281e5c4b7f2487e5d03cd60d8e'
'6f69411d613f6448034508cea52e9574')
TX_COUNT = 126979
TX_COUNT_HEIGHT = 126946
TX_PER_BLOCK = 2
RPC_PORT = 8556
class GameCredits(Coin):
NAME = "GameCredits"
SHORTNAME = "GAME"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("26")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("a6")
GENESIS_HASH = ('91ec5f25ee9a0ffa1af7d4da4db9a552'
'228dd2dc77cdb15b738be4e1f55f30ee')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 316796
TX_COUNT_HEIGHT = 2040250
TX_PER_BLOCK = 2
RPC_PORT = 40001
REORG_LIMIT = 1000
class Machinecoin(Coin):
NAME = "Machinecoin"
SHORTNAME = "MAC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("32")
P2SH_VERBYTES = [bytes.fromhex("26"), bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("b2")
GENESIS_HASH = ('6a1f879bcea5471cbfdee1fd0cb2ddcc'
'4fed569a500e352d41de967703e83172')
DESERIALIZER = lib_tx.DeserializerSegWit
TX_COUNT = 137641
TX_COUNT_HEIGHT = 513020
TX_PER_BLOCK = 2
RPC_PORT = 40332
REORG_LIMIT = 800
class BitcoinAtom(Coin):
NAME = "BitcoinAtom"
SHORTNAME = "BCA"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("17")
P2SH_VERBYTES = [bytes.fromhex("0a")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('000000000019d6689c085ae165831e93'
'4ff763ae46a2a6c172b3f1b60a8ce26f')
STATIC_BLOCK_HEADERS = False
DESERIALIZER = lib_tx.DeserializerBitcoinAtom
HEADER_SIZE_POST_FORK = 84
BLOCK_PROOF_OF_STAKE = 0x01
BLOCK_PROOF_OF_STAKE_FLAGS = b'\x01\x00\x00\x00'
TX_COUNT = 295158744
TX_COUNT_HEIGHT = 589197
TX_PER_BLOCK = 10
RPC_PORT = 7332
REORG_LIMIT = 5000
PEER_DEFAULT_PORTS = {'t': '50003', 's': '50004'}
PEERS = [
'electrum.bitcoinatom.io s t',
'electrum.bitcoinatom.net s t',
'electrumx1.bitcoin-atom.org s t',
'electrumx2.bitcoin-atom.org s t',
'electrumx3.bitcoin-atom.org s t',
'electrumx4.bitcoin-atom.org s t'
]
@classmethod
def header_hash(cls, header):
'''Given a header return hash'''
header_to_be_hashed = header[:cls.BASIC_HEADER_SIZE]
# New block header format has some extra flags in the end
if len(header) == cls.HEADER_SIZE_POST_FORK:
flags, = util.unpack_le_uint32_from(header, len(header) - 4)
# Proof of work blocks have special serialization
if flags & cls.BLOCK_PROOF_OF_STAKE != 0:
header_to_be_hashed += cls.BLOCK_PROOF_OF_STAKE_FLAGS
return double_sha256(header_to_be_hashed)
@classmethod
def block_header(cls, block, height):
'''Return the block header bytes'''
deserializer = cls.DESERIALIZER(block)
return deserializer.read_header(height, cls.BASIC_HEADER_SIZE)
class BitcoinAtomTestnet(BitcoinAtom):
SHORTNAME = "tBCA"
NET = "testnet"
P2PKH_VERBYTE = bytes.fromhex("6f")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ef")
GENESIS_HASH = ('000000000933ea01ad0ee984209779ba'
'aec3ced90fa3f408719526f8d77f4943')
DESERIALIZER = lib_tx.DeserializerBitcoinAtomTestnet
TX_COUNT = 17128321
TX_COUNT_HEIGHT = 1334108
TX_PER_BLOCK = 3
RPC_PORT = 17332
PEER_DEFAULT_PORTS = {'t': '51003', 's': '51004'}
PEERS = [
'electrum-test.bitcoinatom.io s t',
'electrum-test.bitcoinatom.net s t',
'electrumx1-test.bitcoin-atom.org s t'
]
class Decred(Coin):
NAME = "Decred"
SHORTNAME = "DCR"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("02fda926")
XPRV_VERBYTES = bytes.fromhex("02fda4e8")
P2PKH_VERBYTE = bytes.fromhex("073f")
P2SH_VERBYTES = [bytes.fromhex("071a")]
WIF_BYTE = bytes.fromhex("230e")
GENESIS_HASH = ('298e5cc3d985bfe7f81dc135f360abe0'
'89edd4396b86d2de66b0cef42b21d980')
BASIC_HEADER_SIZE = 180
HEADER_HASH = lib_tx.DeserializerDecred.blake256
DESERIALIZER = lib_tx.DeserializerDecred
DAEMON = daemon.DecredDaemon
BLOCK_PROCESSOR = block_proc.DecredBlockProcessor
ENCODE_CHECK = partial(Base58.encode_check,
hash_fn=lib_tx.DeserializerDecred.blake256d)
DECODE_CHECK = partial(Base58.decode_check,
hash_fn=lib_tx.DeserializerDecred.blake256d)
HEADER_VALUES = ('version', 'prev_block_hash', 'merkle_root', 'stake_root',
'vote_bits', 'final_state', 'voters', 'fresh_stake',
'revocations', 'pool_size', 'bits', 'sbits',
'block_height', 'size', 'timestamp', 'nonce',
'extra_data', 'stake_version')
HEADER_UNPACK = struct.Struct(
'< i 32s 32s 32s H 6s H B B I I Q I I I I 32s I').unpack_from
TX_COUNT = 4629388
TX_COUNT_HEIGHT = 260628
TX_PER_BLOCK = 17
REORG_LIMIT = 1000
RPC_PORT = 9109
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
return cls.HEADER_HASH(header)
@classmethod
def block(cls, raw_block, height):
'''Return a Block namedtuple given a raw block and its height.'''
if height > 0:
return super().block(raw_block, height)
else:
return Block(raw_block, cls.block_header(raw_block, height), [])
@classmethod
def electrum_header(cls, header, height):
h = super().electrum_header(header, height)
h['stake_root'] = hash_to_hex_str(h['stake_root'])
h['final_state'] = hash_to_hex_str(h['final_state'])
h['extra_data'] = hash_to_hex_str(h['extra_data'])
return h
class DecredTestnet(Decred):
SHORTNAME = "tDCR"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587d1")
XPRV_VERBYTES = bytes.fromhex("04358397")
P2PKH_VERBYTE = bytes.fromhex("0f21")
P2SH_VERBYTES = [bytes.fromhex("0efc")]
WIF_BYTE = bytes.fromhex("22de")
GENESIS_HASH = (
'4261602a9d07d80ad47621a64ba6a07754902e496777edc4ff581946bd7bc29c')
BASIC_HEADER_SIZE = 180
ALLOW_ADVANCING_ERRORS = True
TX_COUNT = 217380620
TX_COUNT_HEIGHT = 464000
TX_PER_BLOCK = 1800
REORG_LIMIT = 1000
RPC_PORT = 19109
class Axe(Dash):
NAME = "Axe"
SHORTNAME = "AXE"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("02fe52cc")
XPRV_VERBYTES = bytes.fromhex("02fe52f8")
P2PKH_VERBYTE = bytes.fromhex("37")
P2SH_VERBYTES = [bytes.fromhex("10")]
WIF_BYTE = bytes.fromhex("cc")
GENESIS_HASH = ('00000c33631ca6f2f61368991ce2dc03'
'306b5bb50bf7cede5cfbba6db38e52e6')
DAEMON = daemon.DashDaemon
TX_COUNT = 18405
TX_COUNT_HEIGHT = 30237
TX_PER_BLOCK = 1
RPC_PORT = 9337
REORG_LIMIT = 1000
PEERS = []
@classmethod
def header_hash(cls, header):
'''
Given a header return the hash for AXE.
Need to download `axe_hash` module
Source code: https://github.com/AXErunners/axe_hash
'''
import x11_hash
return x11_hash.getPoWHash(header)
class Xuez(Coin):
NAME = "Xuez"
SHORTNAME = "XUEZ"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("022d2533")
XPRV_VERBYTES = bytes.fromhex("0221312b")
P2PKH_VERBYTE = bytes.fromhex("48")
P2SH_VERBYTES = [bytes.fromhex("12")]
WIF_BYTE = bytes.fromhex("d4")
GENESIS_HASH = ('000000e1febc39965b055e8e0117179a'
'4d18e24e7aaa0c69864c4054b4f29445')
TX_COUNT = 30000
TX_COUNT_HEIGHT = 15000
TX_PER_BLOCK = 1
RPC_PORT = 41799
REORG_LIMIT = 1000
BASIC_HEADER_SIZE = 112
PEERS = []
@classmethod
def header_hash(cls, header):
'''
Given a header return the hash for Xuez.
Need to download `xevan_hash` module
Source code: https://github.com/xuez/xuez
'''
version, = util.unpack_le_uint32_from(header)
import xevan_hash
if version == 1:
return xevan_hash.getPoWHash(header[:80])
else:
return xevan_hash.getPoWHash(header)
@classmethod
def electrum_header(cls, header, height):
h = super().electrum_header(header, height)
if h['version'] > 1:
h['nAccumulatorCheckpoint'] = hash_to_hex_str(header[80:])
return h
class Pac(Coin):
NAME = "PAC"
SHORTNAME = "PAC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488B21E")
XPRV_VERBYTES = bytes.fromhex("0488ADE4")
GENESIS_HASH = ('00000354655ff039a51273fe61d3b493'
'bd2897fe6c16f732dbc4ae19f04b789e')
P2PKH_VERBYTE = bytes.fromhex("37")
P2SH_VERBYTES = [bytes.fromhex("0A")]
WIF_BYTE = bytes.fromhex("CC")
TX_COUNT_HEIGHT = 14939
TX_COUNT = 23708
TX_PER_BLOCK = 2
RPC_PORT = 7111
PEERS = [
'electrum.paccoin.io s t',
'electro-pac.paccoin.io s t'
]
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
ESTIMATE_FEE = 0.00001
RELAY_FEE = 0.00001
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import x11_hash
return x11_hash.getPoWHash(header)
class PacTestnet(Pac):
SHORTNAME = "tPAC"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587CF")
XPRV_VERBYTES = bytes.fromhex("04358394")
GENESIS_HASH = ('00000da63bd9478b655ef6bf1bf76cd9'
'af05202ab68643f9091e049b2b5280ed')
P2PKH_VERBYTE = bytes.fromhex("78")
P2SH_VERBYTES = [bytes.fromhex("0E")]
WIF_BYTE = bytes.fromhex("EF")
TX_COUNT_HEIGHT = 16275
TX_COUNT = 16275
TX_PER_BLOCK = 1
RPC_PORT = 17111
class Polis(Coin):
NAME = "Polis"
SHORTNAME = "POLIS"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("03E25D7E")
XPRV_VERBYTES = bytes.fromhex("03E25945")
GENESIS_HASH = ('000009701eb781a8113b1af1d814e2f0'
'60f6408a2c990db291bc5108a1345c1e')
P2PKH_VERBYTE = bytes.fromhex("37")
P2SH_VERBYTES = [bytes.fromhex("38")]
WIF_BYTE = bytes.fromhex("3c")
TX_COUNT_HEIGHT = 111111
TX_COUNT = 256128
TX_PER_BLOCK = 4
RPC_PORT = 24127
PEERS = [
'electrum1-polis.polispay.org',
'electrum2-polis.polispay.org'
]
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import x11_hash
return x11_hash.getPoWHash(header)
class ColossusXT(Coin):
NAME = "ColossusXT"
SHORTNAME = "COLX"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("022D2533")
XPRV_VERBYTES = bytes.fromhex("0221312B")
GENESIS_HASH = ('a0ce8206c908357008c1b9a8ba2813af'
'f0989ca7f72d62b14e652c55f02b4f5c')
P2PKH_VERBYTE = bytes.fromhex("1E")
P2SH_VERBYTES = [bytes.fromhex("0D")]
WIF_BYTE = bytes.fromhex("D4")
TX_COUNT_HEIGHT = 356500
TX_COUNT = 761041
TX_PER_BLOCK = 4
RPC_PORT = 51473
PEERS = [
'electrum1-colx.polispay.org',
'electrum2-colx.polispay.org'
]
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import quark_hash
return quark_hash.getPoWHash(header)
class GoByte(Coin):
NAME = "GoByte"
SHORTNAME = "GBX"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488B21E")
XPRV_VERBYTES = bytes.fromhex("0488ADE4")
GENESIS_HASH = ('0000033b01055cf8df90b01a14734cae'
'92f7039b9b0e48887b4e33a469d7bc07')
P2PKH_VERBYTE = bytes.fromhex("26")
P2SH_VERBYTES = [bytes.fromhex("0A")]
WIF_BYTE = bytes.fromhex("C6")
TX_COUNT_HEIGHT = 115890
TX_COUNT = 245030
TX_PER_BLOCK = 4
RPC_PORT = 12454
PEERS = [
'electrum1-gbx.polispay.org',
'electrum2-gbx.polispay.org'
]
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import neoscrypt
return neoscrypt.getPoWHash(header)
class Monoeci(Coin):
NAME = "Monoeci"
SHORTNAME = "XMCC"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488B21E")
XPRV_VERBYTES = bytes.fromhex("0488ADE4")
GENESIS_HASH = ('0000005be1eb05b05fb45ae38ee9c144'
'1514a65343cd146100a574de4278f1a3')
P2PKH_VERBYTE = bytes.fromhex("32")
P2SH_VERBYTES = [bytes.fromhex("49")]
WIF_BYTE = bytes.fromhex("4D")
TX_COUNT_HEIGHT = 140000
TX_COUNT = 140000
TX_PER_BLOCK = 4
RPC_PORT = 24156
PEERS = [
'electrum1-gbx.polispay.org',
'electrum2-gbx.polispay.org'
]
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import x11_hash
return x11_hash.getPoWHash(header)
class Minexcoin(EquihashMixin, Coin):
NAME = "Minexcoin"
SHORTNAME = "MNX"
NET = "mainnet"
P2PKH_VERBYTE = bytes.fromhex("4b")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('490a36d9451a55ed197e34aca7414b35'
'd775baa4a8e896f1c577f65ce2d214cb')
STATIC_BLOCK_HEADERS = True
BASIC_HEADER_SIZE = 209
HEADER_SIZE_NO_SOLUTION = 140
TX_COUNT = 327963
TX_COUNT_HEIGHT = 74495
TX_PER_BLOCK = 5
RPC_PORT = 8022
CHUNK_SIZE = 960
PEERS = [
'elex01-ams.turinex.eu s t',
'eu.minexpool.nl s t'
]
@classmethod
def electrum_header(cls, header, height):
h = super().electrum_header(header, height)
h['solution'] = hash_to_hex_str(header[cls.HEADER_SIZE_NO_SOLUTION:])
return h
@classmethod
def block_header(cls, block, height):
'''Return the block header bytes'''
deserializer = cls.DESERIALIZER(block)
return deserializer.read_header(height, cls.HEADER_SIZE_NO_SOLUTION)
class Groestlcoin(Coin):
NAME = "Groestlcoin"
SHORTNAME = "GRS"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("24")
P2SH_VERBYTES = [bytes.fromhex("05")]
WIF_BYTE = bytes.fromhex("80")
GENESIS_HASH = ('00000ac5927c594d49cc0bdb81759d0d'
'a8297eb614683d3acb62f0703b639023')
DESERIALIZER = lib_tx.DeserializerGroestlcoin
TX_COUNT = 115900
TX_COUNT_HEIGHT = 1601528
TX_PER_BLOCK = 5
RPC_PORT = 1441
PEERS = [
'electrum1.groestlcoin.org s t',
'electrum2.groestlcoin.org s t',
'6brsrbiinpc32tfc.onion t',
'xkj42efxrcy6vbfw.onion t',
]
def grshash(data):
import groestlcoin_hash
return groestlcoin_hash.getHash(data, len(data))
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
return cls.grshash(header)
ENCODE_CHECK = partial(Base58.encode_check, hash_fn=grshash)
DECODE_CHECK = partial(Base58.decode_check, hash_fn=grshash)
class GroestlcoinTestnet(Groestlcoin):
SHORTNAME = "TGRS"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587cf")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("6f")
P2SH_VERBYTES = [bytes.fromhex("c4")]
WIF_BYTE = bytes.fromhex("ef")
GENESIS_HASH = ('000000ffbb50fc9898cdd36ec163e6ba'
'23230164c0052a28876255b7dcf2cd36')
RPC_PORT = 17766
PEERS = [
'electrum-test1.groestlcoin.org s t',
'electrum-test2.groestlcoin.org s t',
'7frvhgofuf522b5i.onion t',
'aocojvqcybdoxekv.onion t',
]
class Pivx(Coin):
NAME = "Pivx"
SHORTNAME = "PIVX"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("022D2533")
XPRV_VERBYTES = bytes.fromhex("0221312B")
P2PKH_VERBYTE = bytes.fromhex("1e")
P2SH_VERBYTES = [bytes.fromhex("0d")]
WIF_BYTE = bytes.fromhex("d4")
GENESIS_HASH = ('0000041e482b9b9691d98eefb4847340'
'5c0b8ec31b76df3797c74a78680ef818')
BASIC_HEADER_SIZE = 80
HDR_V4_SIZE = 112
HDR_V4_HEIGHT = 863787
HDR_V4_START_OFFSET = HDR_V4_HEIGHT * BASIC_HEADER_SIZE
TX_COUNT = 2930206
TX_COUNT_HEIGHT = 1299212
TX_PER_BLOCK = 2
RPC_PORT = 51473
@classmethod
def static_header_offset(cls, height):
assert cls.STATIC_BLOCK_HEADERS
if height >= cls.HDR_V4_HEIGHT:
relative_v4_offset = (height - cls.HDR_V4_HEIGHT) * cls.HDR_V4_SIZE
return cls.HDR_V4_START_OFFSET + relative_v4_offset
else:
return height * cls.BASIC_HEADER_SIZE
@classmethod
def header_hash(cls, header):
version, = util.unpack_le_uint32_from(header)
if version >= 4:
return super().header_hash(header)
else:
import quark_hash
return quark_hash.getPoWHash(header)
class PivxTestnet(Pivx):
SHORTNAME = "tPIVX"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("3a8061a0")
XPRV_VERBYTES = bytes.fromhex("3a805837")
P2PKH_VERBYTE = bytes.fromhex("8B")
P2SH_VERBYTES = [bytes.fromhex("13")]
WIF_BYTE = bytes.fromhex("EF")
GENESIS_HASH = (
'0000041e482b9b9691d98eefb48473405c0b8ec31b76df3797c74a78680ef818')
BASIC_HEADER_SIZE = 80
HDR_V4_SIZE = 112
HDR_V4_HEIGHT = 863787
HDR_V4_START_OFFSET = HDR_V4_HEIGHT * BASIC_HEADER_SIZE
TX_COUNT = 2157510
TX_COUNT_HEIGHT = 569399
TX_PER_BLOCK = 2
RPC_PORT = 51472
class Bitg(Coin):
NAME = "BitcoinGreen"
SHORTNAME = "BITG"
NET = "mainnet"
XPUB_VERBYTES = bytes.fromhex("0488b21e")
XPRV_VERBYTES = bytes.fromhex("0488ade4")
P2PKH_VERBYTE = bytes.fromhex("26")
P2SH_VERBYTES = [bytes.fromhex("06")]
WIF_BYTE = bytes.fromhex("2e")
GENESIS_HASH = (
'000008467c3a9c587533dea06ad9380cded3ed32f9742a6c0c1aebc21bf2bc9b')
DAEMON = daemon.DashDaemon
TX_COUNT = 1000
TX_COUNT_HEIGHT = 10000
TX_PER_BLOCK = 1
RPC_PORT = 9332
REORG_LIMIT = 1000
SESSIONCLS = DashElectrumX
DAEMON = daemon.DashDaemon
@classmethod
def header_hash(cls, header):
'''Given a header return the hash.'''
import quark_hash
return quark_hash.getPoWHash(header)
class tBitg(Bitg):
SHORTNAME = "tBITG"
NET = "testnet"
XPUB_VERBYTES = bytes.fromhex("043587cf")
XPRV_VERBYTES = bytes.fromhex("04358394")
P2PKH_VERBYTE = bytes.fromhex("62")
P2SH_VERBYTES = [bytes.fromhex("0c")]
WIF_BYTE = bytes.fromhex("6c")
GENESIS_HASH = (
'000008467c3a9c587533dea06ad9380cded3ed32f9742a6c0c1aebc21bf2bc9b')
RPC_PORT = 19332
| 31.043864 | 79 | 0.652742 |
e051083f0d3ca23207055b9c6147a664e2256190 | 5,956 | py | Python | asyncqt/_windows.py | razaqq/PotatoAlertpy | 0ae472e73109f85bea01ca1b45b8f2f1cfd64e63 | [
"MIT"
]
| null | null | null | asyncqt/_windows.py | razaqq/PotatoAlertpy | 0ae472e73109f85bea01ca1b45b8f2f1cfd64e63 | [
"MIT"
]
| null | null | null | asyncqt/_windows.py | razaqq/PotatoAlertpy | 0ae472e73109f85bea01ca1b45b8f2f1cfd64e63 | [
"MIT"
]
| null | null | null | # © 2018 Gerard Marull-Paretas <[email protected]>
# © 2014 Mark Harviston <[email protected]>
# © 2014 Arve Knudsen <[email protected]>
# BSD License
"""Windows specific Quamash functionality."""
import asyncio
import sys
try:
import _winapi
from asyncio import windows_events
import _overlapped
except ImportError: # noqa
pass # w/o guarding this import py.test can't gather doctests on platforms w/o _winapi
import math
from . import QtCore, _make_signaller
from ._common import with_logger
UINT32_MAX = 0xffffffff
class _ProactorEventLoop(asyncio.ProactorEventLoop):
"""Proactor based event loop."""
def __init__(self):
super().__init__(_IocpProactor())
self.__event_signaller = _make_signaller(QtCore, list)
self.__event_signal = self.__event_signaller.signal
self.__event_signal.connect(self._process_events)
self.__event_poller = _EventPoller(self.__event_signal)
def _process_events(self, events):
"""Process events from proactor."""
for f, callback, transferred, key, ov in events:
try:
self._logger.debug('Invoking event callback {}'.format(callback))
value = callback(transferred, key, ov)
except OSError:
self._logger.warning('Event callback failed', exc_info=sys.exc_info())
else:
if not f.done():
f.set_result(value)
def _before_run_forever(self):
self.__event_poller.start(self._proactor)
def _after_run_forever(self):
self.__event_poller.stop()
@with_logger
class _IocpProactor(windows_events.IocpProactor):
def __init__(self):
self.__events = []
super(_IocpProactor, self).__init__()
self._lock = QtCore.QMutex()
def select(self, timeout=None):
"""Override in order to handle events in a threadsafe manner."""
if not self.__events:
self._poll(timeout)
tmp = self.__events
self.__events = []
return tmp
def close(self):
self._logger.debug('Closing')
super(_IocpProactor, self).close()
def recv(self, conn, nbytes, flags=0):
with QtCore.QMutexLocker(self._lock):
return super(_IocpProactor, self).recv(conn, nbytes, flags)
def send(self, conn, buf, flags=0):
with QtCore.QMutexLocker(self._lock):
return super(_IocpProactor, self).send(conn, buf, flags)
def _poll(self, timeout=None):
"""Override in order to handle events in a threadsafe manner."""
if timeout is None:
ms = UINT32_MAX # wait for eternity
elif timeout < 0:
raise ValueError("negative timeout")
else:
# GetQueuedCompletionStatus() has a resolution of 1 millisecond,
# round away from zero to wait *at least* timeout seconds.
ms = math.ceil(timeout * 1e3)
if ms >= UINT32_MAX:
raise ValueError("timeout too big")
with QtCore.QMutexLocker(self._lock):
while True:
# self._logger.debug('Polling IOCP with timeout {} ms in thread {}...'.format(
# ms, threading.get_ident()))
status = _overlapped.GetQueuedCompletionStatus(self._iocp, ms)
if status is None:
break
err, transferred, key, address = status
try:
f, ov, obj, callback = self._cache.pop(address)
except KeyError:
# key is either zero, or it is used to return a pipe
# handle which should be closed to avoid a leak.
if key not in (0, _overlapped.INVALID_HANDLE_VALUE):
_winapi.CloseHandle(key)
ms = 0
continue
if obj in self._stopped_serving:
f.cancel()
# Futures might already be resolved or cancelled
elif not f.done():
self.__events.append((f, callback, transferred, key, ov))
ms = 0
def _wait_for_handle(self, handle, timeout, _is_cancel):
with QtCore.QMutexLocker(self._lock):
return super(_IocpProactor, self)._wait_for_handle(handle, timeout, _is_cancel)
def accept(self, listener):
with QtCore.QMutexLocker(self._lock):
return super(_IocpProactor, self).accept(listener)
def connect(self, conn, address):
with QtCore.QMutexLocker(self._lock):
return super(_IocpProactor, self).connect(conn, address)
@with_logger
class _EventWorker(QtCore.QThread):
def __init__(self, proactor, parent):
super().__init__()
self.__stop = False
self.__proactor = proactor
self.__sig_events = parent.sig_events
self.__semaphore = QtCore.QSemaphore()
def start(self):
super().start()
self.__semaphore.acquire()
def stop(self):
self.__stop = True
# Wait for thread to end
self.wait()
def run(self):
self._logger.debug('Thread started')
self.__semaphore.release()
while not self.__stop:
events = self.__proactor.select(0.01)
if events:
self._logger.debug('Got events from poll: {}'.format(events))
self.__sig_events.emit(events)
self._logger.debug('Exiting thread')
@with_logger
class _EventPoller:
"""Polling of events in separate thread."""
def __init__(self, sig_events):
self.sig_events = sig_events
def start(self, proactor):
self._logger.debug('Starting (proactor: {})...'.format(proactor))
self.__worker = _EventWorker(proactor, self)
self.__worker.start()
def stop(self):
self._logger.debug('Stopping worker thread...')
self.__worker.stop()
| 32.194595 | 94 | 0.608294 |
8a5fffaa1545e3cb9cf7f05b8bf32022ecedfce5 | 12,700 | py | Python | perfkitbenchmarker/linux_benchmarks/multichase_benchmark.py | parsa-epfl/PerfKitBenchmarker | 7a7981100ebf68d6a24a8a347464800f40c47aa5 | [
"Apache-2.0"
]
| 1 | 2016-12-07T19:49:58.000Z | 2016-12-07T19:49:58.000Z | perfkitbenchmarker/linux_benchmarks/multichase_benchmark.py | parsa-epfl/PerfKitBenchmarker | 7a7981100ebf68d6a24a8a347464800f40c47aa5 | [
"Apache-2.0"
]
| null | null | null | perfkitbenchmarker/linux_benchmarks/multichase_benchmark.py | parsa-epfl/PerfKitBenchmarker | 7a7981100ebf68d6a24a8a347464800f40c47aa5 | [
"Apache-2.0"
]
| 1 | 2021-12-07T13:29:48.000Z | 2021-12-07T13:29:48.000Z | # Copyright 2016 PerfKitBenchmarker 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.
"""Runs a benchmark from the multichase benchmark suite.
multichase is a pointer chaser benchmark. It measures the average latency of
pointer-chase operations.
multichase codebase: https://github.com/google/multichase
"""
import itertools
import posixpath
from perfkitbenchmarker import configs
from perfkitbenchmarker import flag_util
from perfkitbenchmarker import flags
from perfkitbenchmarker import sample
from perfkitbenchmarker import units
from perfkitbenchmarker.linux_packages import multichase
_CHASES_WITHOUT_ARGS = (
'simple', 'incr', 't0', 't1', 't2', 'nta', 'movdqa', 'movntdqa',
'parallel2', 'parallel3', 'parallel4', 'parallel5', 'parallel6',
'parallel7', 'parallel8', 'parallel9', 'parallel10')
_CHASES_WITH_ARGS = 'critword', 'critword2', 'work'
# Dict mapping possible chase types accepted by the multichase -c flag to a
# boolean indicating whether the chase requires an integer argument. For
# example, the 'simple' chase type does not require an argument and is specified
# as `multichase -c simple`, but the 'work' chase type requires an argument and
# is specified as `multichase -c work:N`.
_CHASES = {c: c in _CHASES_WITH_ARGS
for c in _CHASES_WITHOUT_ARGS + _CHASES_WITH_ARGS}
_BENCHMARK_SPECIFIC_VM_STATE_ATTR = 'multichase_vm_state'
BENCHMARK_NAME = 'multichase'
BENCHMARK_CONFIG = """
multichase:
description: >
Run a benchmark from the multichase benchmark suite.
vm_groups:
default:
vm_spec: *default_single_core
"""
FLAGS = flags.FLAGS
class _MemorySizeParser(flag_util.UnitsParser):
syntactic_help = (
"An explicit memory size that must be convertible to an integer number "
"of bytes (e.g. '7.5 MiB') or a percentage of the total memory rounded "
"down to the next integer byte (e.g. '97.5%', which translates to "
"1046898278 bytes if a total of 1 GiB memory is available).")
def __init__(self):
super(_MemorySizeParser, self).__init__(convertible_to=(units.byte,
units.percent))
def Parse(self, inp):
"""Parse the input.
Args:
inp: string or units.Quantity.
Returns:
A units.Quantity.
Raises:
ValueError: If the input cannot be parsed, or if it parses to a value that
does not meet the requirements described in self.syntactic_help.
"""
size = super(_MemorySizeParser, self).Parse(inp)
if size.units != units.percent:
size_byte_count = size.to(units.byte).magnitude
if size_byte_count != int(size_byte_count):
raise ValueError(
'Expression {0!r} parses to memory size {1!r}, which is not '
'convertible to an integer number of bytes.'.format(inp, str(size)))
return size
_MEMORY_SIZE_PARSER = _MemorySizeParser()
_UNITS_SERIALIZER = flag_util.UnitsSerializer()
_DEFAULT_MEMORY_SIZE = units.Quantity('256 MiB')
_DEFAULT_STRIDE_SIZE = units.Quantity('256 bytes')
def _DefineMemorySizeFlag(name, default, help, flag_values=FLAGS, **kwargs):
flags.DEFINE(_MEMORY_SIZE_PARSER, name, default, help, flag_values,
_UNITS_SERIALIZER, **kwargs)
flags.DEFINE_enum(
'multichase_chase_type', 'simple', sorted(_CHASES),
'Chase type to use when executing multichase. Passed to multichase via its '
'-c flag.')
flags.DEFINE_integer(
'multichase_chase_arg', 1,
'Argument to refine the chase type specified with --multichase_chase_type. '
'Applicable for the following types: {0}.'.format(', '.join(
_CHASES_WITH_ARGS)))
flags.DEFINE_integer(
'multichase_thread_count', 1,
'Number of threads (one per core), to use when executing multichase. '
'Passed to multichase via its -t flag.')
_DefineMemorySizeFlag(
'multichase_memory_size_min', _DEFAULT_MEMORY_SIZE,
'Memory size to use when executing multichase. Passed to multichase via '
'its -m flag. If it differs from multichase_memory_size_max, then '
'multichase is executed multiple times, starting with a memory size equal '
'to the min and doubling while the memory size does not exceed the max. '
'Can be specified as a percentage of the total memory on the machine.')
_DefineMemorySizeFlag(
'multichase_memory_size_max', _DEFAULT_MEMORY_SIZE,
'Memory size to use when executing multichase. Passed to multichase via '
'its -m flag. If it differs from multichase_memory_size_min, then '
'multichase is executed multiple times, starting with a memory size equal '
'to the min and doubling while the memory size does not exceed the max. '
'Can be specified as a percentage of the total memory on the machine.')
_DefineMemorySizeFlag(
'multichase_stride_size_min', _DEFAULT_STRIDE_SIZE,
'Stride size to use when executing multichase. Passed to multichase via '
'its -s flag. If it differs from multichase_stride_size_max, then '
'multichase is executed multiple times, starting with a stride size equal '
'to the min and doubling while the stride size does not exceed the max. '
'Can be specified as a percentage of the maximum memory (-m flag) of each '
'multichase execution.')
_DefineMemorySizeFlag(
'multichase_stride_size_max', _DEFAULT_STRIDE_SIZE,
'Stride size to use when executing multichase. Passed to multichase via '
'its -s flag. If it differs from multichase_stride_size_min, then '
'multichase is executed multiple times, starting with a stride size equal '
'to the min and doubling while the stride size does not exceed the max. '
'Can be specified as a percentage of the maximum memory (-m flag) of each '
'multichase execution.')
flags.DEFINE_string(
'multichase_taskset_options', None,
"If provided, taskset is used to limit the cores available to multichase. "
"The value of this flag contains the options to provide to taskset. "
"Examples: '0x00001FE5' or '-c 0,2,5-12'.")
flags.DEFINE_string(
'multichase_additional_flags', '',
"Additional flags to use when executing multichase. Example: '-O 16 -y'.")
def _TranslateMemorySize(get_total_memory, size):
"""Translates a value parsed from a memory size flag to a byte count.
Args:
get_total_memory: Function that accepts no arguments and returns an integer
specifying the total amount of memory available in bytes.
size: units.Quantity specifying either an explicit memory size in a unit
convertible to bytes or a percentage of the total memory.
Returns:
int expressing the specified memory size in bytes.
"""
if size.units == units.percent:
return int(get_total_memory() * size.magnitude / 100.)
return int(size.to(units.byte).magnitude)
def _IterMemorySizes(get_total_memory, min_size, max_size):
"""Iterates over a range of memory sizes determined by a min and max.
Args:
get_total_memory: Function that accepts no arguments and returns an integer
specifying the total amount of memory available.
min_size: units.Quantity specifying either an explicit memory size in a unit
convertible to bytes or a percentage of the total memory.
max_size: units.Quantity specifying either an explicit memory size in a unit
convertible to bytes or a percentage of the total memory.
Yields:
int expressing memory sizes in bytes. The first yielded value is the
specified minimum size, each subsequent yielded value is twice the previous,
and no yielded values are greater than the specified maximum size. If
max_size specifies a size that is less than min_size, no values are yielded.
"""
min_bytes = _TranslateMemorySize(get_total_memory, min_size)
max_bytes = _TranslateMemorySize(get_total_memory, max_size)
size = min_bytes
while size <= max_bytes:
yield size
size *= 2
def GetConfig(user_config):
return configs.LoadConfig(BENCHMARK_CONFIG, user_config, BENCHMARK_NAME)
def CheckPrerequisites(benchmark_config):
"""Performs input verification checks.
Raises:
ValueError: If an invalid combination of flag values is specified.
"""
chase_type = FLAGS.multichase_chase_type
if not _CHASES[chase_type] and FLAGS['multichase_chase_arg'].present:
raise ValueError(
'Cannot use --multichase_chase_arg with chase type {0!r}. Chase type '
'{0!r} does not require an argument.'.format(chase_type))
class _MultichaseSpecificState(object):
"""State specific to this benchmark that must be preserved between PKB stages.
An instance of this class is attached to the VM as an attribute and is
therefore preserved as part of the pickled BenchmarkSpec between PKB stages.
Attributes:
dir: Optional string. Path of a directory on the remote machine where files
files related to this benchmark are stored.
multichase_dir: Optional string. Path of a directory on the remote machine
where multichase files are stored. A subdirectory within dir.
"""
def __init__(self):
self.dir = None
self.multichase_dir = None
def Prepare(benchmark_spec):
"""Install multichase on the VM.
Args:
benchmark_spec: BenchmarkSpec.
"""
vm = benchmark_spec.vms[0]
vm_state = _MultichaseSpecificState()
setattr(vm, _BENCHMARK_SPECIFIC_VM_STATE_ATTR, vm_state)
vm.Install('multichase')
remote_benchmark_dir = '_'.join(('pkb', FLAGS.run_uri, benchmark_spec.uid))
vm.RemoteCommand('mkdir ' + remote_benchmark_dir)
vm_state.dir = remote_benchmark_dir
vm_state.multichase_dir = posixpath.join(vm_state.dir, 'multichase')
vm.RemoteCommand('cp -ar {0} {1}'.format(
multichase.INSTALL_PATH, vm_state.multichase_dir))
def Run(benchmark_spec):
"""Run multichase on the VM.
Args:
benchmark_spec: BenchmarkSpec.
Returns:
A list of sample.Sample objects.
"""
samples = []
base_metadata = {'additional_flags': FLAGS.multichase_additional_flags,
'chase_type': FLAGS.multichase_chase_type,
'multichase_version': multichase.GIT_VERSION,
'thread_count': FLAGS.multichase_thread_count}
vm = benchmark_spec.vms[0]
vm_state = getattr(vm, _BENCHMARK_SPECIFIC_VM_STATE_ATTR)
base_cmd = []
if FLAGS.multichase_taskset_options:
base_cmd.extend(('taskset', FLAGS.multichase_taskset_options))
base_metadata['taskset_options'] = FLAGS.multichase_taskset_options
multichase_path = posixpath.join(vm_state.multichase_dir, 'multichase')
base_cmd.extend((multichase_path, '-a', '-v'))
chase_type = FLAGS.multichase_chase_type
if _CHASES[chase_type]:
chase_type = '{0}:{1}'.format(chase_type, FLAGS.multichase_chase_arg)
base_metadata['chase_arg'] = FLAGS.multichase_chase_arg
base_cmd.extend(('-c', chase_type))
base_cmd.extend(('-t', FLAGS.multichase_thread_count))
memory_size_iterator = _IterMemorySizes(
lambda: vm.total_memory_kb * 1024, FLAGS.multichase_memory_size_min,
FLAGS.multichase_memory_size_max)
for memory_size in memory_size_iterator:
stride_size_iterator = _IterMemorySizes(
lambda: memory_size, FLAGS.multichase_stride_size_min,
FLAGS.multichase_stride_size_max)
for stride_size in stride_size_iterator:
cmd = ' '.join(str(s) for s in itertools.chain(base_cmd, (
'-m', memory_size, '-s', stride_size,
FLAGS.multichase_additional_flags)))
stdout, _ = vm.RemoteCommand(cmd)
# Latency is printed in ns in the last line.
latency_ns = float(stdout.split()[-1])
# Generate one sample from one run of multichase.
metadata = base_metadata.copy()
metadata.update({'memory_size_bytes': memory_size,
'stride_size_bytes': stride_size})
samples.append(sample.Sample('latency', latency_ns, 'ns', metadata))
return samples
def Cleanup(benchmark_spec):
"""Remove multichase from the VM.
Args:
benchmark_spec: BenchmarkSpec.
"""
vm = benchmark_spec.vms[0]
vm_state = getattr(vm, _BENCHMARK_SPECIFIC_VM_STATE_ATTR)
if vm_state.dir:
# Directory has been created on the VM. Delete it.
vm.RemoteCommand('rm -rf ' + vm_state.dir)
| 39.197531 | 80 | 0.729134 |
23e3a60f63c2b3a239446868840ede320a8c1440 | 10,600 | py | Python | pex/util.py | maguro/pex | b9217232a913e8d32fb78e8c1625f7b56e05f613 | [
"Apache-2.0"
]
| null | null | null | pex/util.py | maguro/pex | b9217232a913e8d32fb78e8c1625f7b56e05f613 | [
"Apache-2.0"
]
| null | null | null | pex/util.py | maguro/pex | b9217232a913e8d32fb78e8c1625f7b56e05f613 | [
"Apache-2.0"
]
| null | null | null | # Copyright 2014 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import absolute_import
import contextlib
import os
import sys
import tempfile
from hashlib import sha1
from site import makepath # type: ignore[attr-defined]
from pex.common import atomic_directory, safe_mkdir, safe_mkdtemp
from pex.compatibility import ( # type: ignore[attr-defined] # `exec_function` is defined dynamically
PY2,
exec_function,
)
from pex.third_party.pkg_resources import (
find_distributions,
resource_isdir,
resource_listdir,
resource_string,
)
from pex.tracer import TRACER
class DistributionHelper(object):
@classmethod
def access_zipped_assets(cls, static_module_name, static_path, dir_location=None):
"""Create a copy of static resource files as we can't serve them from within the pex file.
:param static_module_name: Module name containing module to cache in a tempdir
:type static_module_name: string, for example 'twitter.common.zookeeper' or similar
:param static_path: Module name, for example 'serverset'
:param dir_location: create a new temporary directory inside, or None to have one created
:returns temp_dir: Temporary directory with the zipped assets inside
:rtype: str
"""
# asset_path is initially a module name that's the same as the static_path, but will be
# changed to walk the directory tree
# TODO(John Sirois): Unify with `pex.third_party.isolated(recursive_copy)`.
def walk_zipped_assets(static_module_name, static_path, asset_path, temp_dir):
for asset in resource_listdir(static_module_name, asset_path):
if not asset:
# The `resource_listdir` function returns a '' asset for the directory entry
# itself if it is either present on the filesystem or present as an explicit
# zip entry. Since we only care about files and subdirectories at this point,
# skip these assets.
continue
asset_target = os.path.normpath(
os.path.join(os.path.relpath(asset_path, static_path), asset)
)
if resource_isdir(static_module_name, os.path.join(asset_path, asset)):
safe_mkdir(os.path.join(temp_dir, asset_target))
walk_zipped_assets(
static_module_name, static_path, os.path.join(asset_path, asset), temp_dir
)
else:
with open(os.path.join(temp_dir, asset_target), "wb") as fp:
path = os.path.join(static_path, asset_target)
file_data = resource_string(static_module_name, path)
fp.write(file_data)
if dir_location is None:
temp_dir = safe_mkdtemp()
else:
temp_dir = dir_location
walk_zipped_assets(static_module_name, static_path, static_path, temp_dir)
return temp_dir
@classmethod
def distribution_from_path(cls, path, name=None):
"""Return a distribution from a path.
If name is provided, find the distribution. If none is found matching the name, return
None. If name is not provided and there is unambiguously a single distribution, return that
distribution otherwise None.
"""
if name is None:
distributions = set(find_distributions(path))
if len(distributions) == 1:
return distributions.pop()
else:
for dist in find_distributions(path):
if dist.project_name == name:
return dist
class CacheHelper(object):
@classmethod
def update_hash(cls, filelike, digest):
"""Update the digest of a single file in a memory-efficient manner."""
block_size = digest.block_size * 1024
for chunk in iter(lambda: filelike.read(block_size), b""):
digest.update(chunk)
@classmethod
def hash(cls, path, digest=None, hasher=sha1):
"""Return the digest of a single file in a memory-efficient manner."""
if digest is None:
digest = hasher()
with open(path, "rb") as fh:
cls.update_hash(fh, digest)
return digest.hexdigest()
@classmethod
def _compute_hash(cls, names, stream_factory):
digest = sha1()
# Always use / as the path separator, since that's what zip uses.
hashed_names = [n.replace(os.sep, "/") for n in names]
digest.update("".join(hashed_names).encode("utf-8"))
for name in names:
with contextlib.closing(stream_factory(name)) as fp:
cls.update_hash(fp, digest)
return digest.hexdigest()
@classmethod
def _iter_files(cls, directory):
normpath = os.path.realpath(os.path.normpath(directory))
for root, _, files in os.walk(normpath):
for f in files:
yield os.path.relpath(os.path.join(root, f), normpath)
@classmethod
def pex_hash(cls, d):
"""Return a reproducible hash of the contents of a directory."""
names = sorted(
f for f in cls._iter_files(d) if not (f.endswith(".pyc") or f.startswith("."))
)
def stream_factory(name):
return open(os.path.join(d, name), "rb") # noqa: T802
return cls._compute_hash(names, stream_factory)
@classmethod
def dir_hash(cls, d):
"""Return a reproducible hash of the contents of a directory."""
names = sorted(f for f in cls._iter_files(d) if not f.endswith(".pyc"))
def stream_factory(name):
return open(os.path.join(d, name), "rb") # noqa: T802
return cls._compute_hash(names, stream_factory)
@classmethod
def cache_distribution(cls, zf, source, target_dir):
"""Possibly cache a wheel from within a zipfile into `target_dir`.
Given a zipfile handle and a source path prefix corresponding to a wheel install embedded within
that zip, maybe extract the wheel install into the target cache and then return a distribution
from the cache.
:param zf: An open zip file (a zipped pex).
:type zf: :class:`zipfile.ZipFile`
:param str source: The path prefix of a wheel install embedded in the zip file.
:param str target_dir: The directory to cache the distribution in if not already cached.
:returns: The cached distribution.
:rtype: :class:`pex.third_party.pkg_resources.Distribution`
"""
with atomic_directory(target_dir, source=source) as target_dir_tmp:
if target_dir_tmp is None:
TRACER.log("Using cached {}".format(target_dir))
else:
with TRACER.timed("Caching {}:{} in {}".format(zf.filename, source, target_dir)):
for name in zf.namelist():
if name.startswith(source) and not name.endswith("/"):
zf.extract(name, target_dir_tmp)
dist = DistributionHelper.distribution_from_path(target_dir)
assert dist is not None, "Failed to cache distribution: {} ".format(source)
return dist
@contextlib.contextmanager
def named_temporary_file(*args, **kwargs):
"""Due to a bug in python (https://bugs.python.org/issue14243), we need this to be able to use
the temporary file without deleting it."""
assert "delete" not in kwargs
kwargs["delete"] = False
fp = tempfile.NamedTemporaryFile(*args, **kwargs)
try:
with fp:
yield fp
finally:
os.remove(fp.name)
def iter_pth_paths(filename):
"""Given a .pth file, extract and yield all inner paths without honoring imports.
This shadows Python's site.py behavior, which is invoked at interpreter startup.
"""
try:
f = open(filename, "rU" if PY2 else "r") # noqa
except IOError:
return
dirname = os.path.dirname(filename)
known_paths = set()
with f:
for i, line in enumerate(f, start=1):
line = line.rstrip()
if not line or line.startswith("#"):
continue
elif line.startswith(("import ", "import\t")):
# One important side effect of executing import lines can be alteration of the
# sys.path directly or indirectly as a programmatic way to add sys.path entries
# in contrast to the standard .pth mechanism of including fixed paths as
# individual lines in the file. Here we capture all such programmatic attempts
# to expand the sys.path and report the additions.
original_sys_path = sys.path[:]
try:
# N.B.: Setting sys.path to empty is ok since all the .pth files we find and
# execute have already been found and executed by our ambient sys.executable
# when it started up before running this PEX file. As such, all symbols imported
# by the .pth files then will still be available now as cached in sys.modules.
sys.path = []
exec_function(line, globals_map={})
for path in sys.path:
yield path
except Exception as e:
# NB: import lines are routinely abused with extra code appended using `;` so
# the class of exceptions that might be raised in broader than ImportError. As
# such we catch broadly here.
TRACER.log(
"Error executing line {linenumber} of {pth_file} with content:\n"
"{content}\n"
"Error was:\n"
"{error}".format(linenumber=i, pth_file=filename, content=line, error=e),
V=9,
)
# Defer error handling to the higher level site.py logic invoked at startup.
return
finally:
sys.path = original_sys_path
else:
extras_dir, extras_dir_case_insensitive = makepath(dirname, line)
if extras_dir_case_insensitive not in known_paths and os.path.exists(extras_dir):
yield extras_dir
known_paths.add(extras_dir_case_insensitive)
| 43.089431 | 104 | 0.613868 |
7b1e569200abb9fb67afb43860516b2b61009c30 | 1,498 | py | Python | CCU/air/code.py | andrew-jolley/leventhorpe-cansat | 5410bd73d114667ccdebf3ec93be3b2f04f91e5b | [
"MIT"
]
| null | null | null | CCU/air/code.py | andrew-jolley/leventhorpe-cansat | 5410bd73d114667ccdebf3ec93be3b2f04f91e5b | [
"MIT"
]
| null | null | null | CCU/air/code.py | andrew-jolley/leventhorpe-cansat | 5410bd73d114667ccdebf3ec93be3b2f04f91e5b | [
"MIT"
]
| null | null | null | # importing other information
import digitalio
import board
import time
#import bmp280
import radio
import carbon
led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT
led.value = True
packet_count = 0
while True:
led.value = not led.value
print("Radio message sent")
new_carbon = carbon.value()
new_temp = carbon.temp()
new_humidity = carbon.humidity()
new_altitude = carbon.altitude()
#cansat_temperature = bmp280.read_temperature()
#room_temp = bmp280.read_temperature()
#print(cansat_temperature)
#cansat_pressure = bmp280.read_pressure()
#room_pressure = bmp280.read_pressure()
#print(cansat_pressure)
#Q = 44330 * (1 - (1/1043.4) ** (1/5.255))
#print("CO2: {:.2f} PPM, Pressure: {:.2f} mbar, Temperature: {:.2f} degrees C, Temperature: {:.2f} degrees C, Humidity: {:.1f} %%rH, Altitude: {:.0f}M.".format(new_carbon, carbon.temp, new_temp, carbon.temp, new_humidity, Q))
#print("Temperature: {:.3f}^C Pressure: QNH {:.2f}".format(cansat_temperature, cansat_pressure))
#radio.send("[LevCanSat] Temperature: {:.2f} Pressure {:.0f} mbar".format(room_temp, room_pressure))
radio.send("[LevCanSat] CO2: {:.2f} PPM, Pressure: {:.2f} mbar, Temperature: {:.2f} degrees C, Temperature: {:.2f} degrees C, Humidity: {:.1f} %%rH, Altitude: {:.0f}M.".format(new_carbon, carbon.temp, new_temp, carbon.temp, new_humidity, Q))
led.direction = digitalio.Direction.OUTPUT
time.sleep(1)
| 31.87234 | 245 | 0.686248 |
3e684a39e0854e31aa30394b2315832d4f05e2d5 | 2,740 | py | Python | dateparser/data/date_translation_data/ff.py | bsekiewicz/dateparser | babc677372376d933de5542010af3097c26e49e9 | [
"BSD-3-Clause"
]
| 1,804 | 2015-01-01T23:01:54.000Z | 2022-03-30T18:36:16.000Z | dateparser/data/date_translation_data/ff.py | bsekiewicz/dateparser | babc677372376d933de5542010af3097c26e49e9 | [
"BSD-3-Clause"
]
| 948 | 2015-01-04T22:18:39.000Z | 2022-03-31T16:29:41.000Z | dateparser/data/date_translation_data/ff.py | bsekiewicz/dateparser | babc677372376d933de5542010af3097c26e49e9 | [
"BSD-3-Clause"
]
| 463 | 2015-01-10T08:53:39.000Z | 2022-03-18T12:45:49.000Z | info = {
"name": "ff",
"date_order": "DMY",
"january": [
"sii",
"siilo"
],
"february": [
"col",
"colte"
],
"march": [
"mbo",
"mbooy"
],
"april": [
"see",
"seeɗto"
],
"may": [
"duu",
"duujal"
],
"june": [
"kor",
"korse"
],
"july": [
"mor",
"morso"
],
"august": [
"juk",
"juko"
],
"september": [
"siilto",
"slt"
],
"october": [
"yar",
"yarkomaa"
],
"november": [
"jol",
"jolal"
],
"december": [
"bow",
"bowte"
],
"monday": [
"aaɓ",
"aaɓnde"
],
"tuesday": [
"maw",
"mawbaare"
],
"wednesday": [
"nje",
"njeslaare"
],
"thursday": [
"naa",
"naasaande"
],
"friday": [
"mawnde",
"mwd"
],
"saturday": [
"hbi",
"hoore-biir"
],
"sunday": [
"dew",
"dewo"
],
"am": [
"subaka"
],
"pm": [
"kikiiɗe"
],
"year": [
"hitaande"
],
"month": [
"lewru"
],
"week": [
"yontere"
],
"day": [
"ñalnde"
],
"hour": [
"waktu"
],
"minute": [
"hoƴom"
],
"second": [
"majaango"
],
"relative-type": {
"0 day ago": [
"hannde"
],
"0 hour ago": [
"this hour"
],
"0 minute ago": [
"this minute"
],
"0 month ago": [
"this month"
],
"0 second ago": [
"now"
],
"0 week ago": [
"this week"
],
"0 year ago": [
"this year"
],
"1 day ago": [
"haŋki"
],
"1 month ago": [
"last month"
],
"1 week ago": [
"last week"
],
"1 year ago": [
"last year"
],
"in 1 day": [
"jaŋngo"
],
"in 1 month": [
"next month"
],
"in 1 week": [
"next week"
],
"in 1 year": [
"next year"
]
},
"locale_specific": {
"ff-CM": {
"name": "ff-CM"
},
"ff-GN": {
"name": "ff-GN"
},
"ff-MR": {
"name": "ff-MR"
}
},
"skip": [
" ",
"'",
",",
"-",
".",
"/",
";",
"@",
"[",
"]",
"|",
"，"
]
}
| 15.222222 | 27 | 0.260219 |
28ee0fb47b9ca9d59962b829d8e3a018a11b2500 | 859 | py | Python | tests/test_ptz.py | delin/zm-py | 3b209185991e8ae7dfe3dde8c2f8462f134afb9f | [
"Apache-2.0"
]
| 10 | 2018-09-27T06:33:56.000Z | 2021-07-10T09:49:57.000Z | tests/test_ptz.py | delin/zm-py | 3b209185991e8ae7dfe3dde8c2f8462f134afb9f | [
"Apache-2.0"
]
| 21 | 2018-09-15T18:59:05.000Z | 2021-11-29T23:53:52.000Z | tests/test_ptz.py | delin/zm-py | 3b209185991e8ae7dfe3dde8c2f8462f134afb9f | [
"Apache-2.0"
]
| 11 | 2019-01-26T23:08:00.000Z | 2021-11-26T04:40:16.000Z | """Tests to verify ControlType."""
from pytest import mark, raises
from zoneminder.monitor import ControlType
from zoneminder.exceptions import ControlTypeError
@mark.parametrize(
"source,want",
[
("right", ControlType.RIGHT),
("LEFT", ControlType.LEFT),
("UP_LEFT", ControlType.UP_LEFT),
("down-LEFT", ControlType.DOWN_LEFT),
],
)
def test_control_type_from_move(source, want):
"""Verifies that ControlType return correct move type."""
assert ControlType.from_move(source) == want
@mark.parametrize(
"source,want",
[
("UP-DOWN", raises(ControlTypeError)),
("rigth", raises(ControlTypeError)),
],
)
def test_control_type_from_move_wrong_move(source, want):
"""Verifies that ControlType return correct exceptions."""
with want:
ControlType.from_move(source)
| 25.264706 | 62 | 0.678696 |
828c63715d6a138157178598a5879f2e7874fba2 | 1,102 | py | Python | geodj/genre_parser.py | teopeurt/GeoDJ | 2bc7da9f10ea17ed22565fb9cad197601cce950d | [
"MIT"
]
| 1 | 2018-07-23T16:57:36.000Z | 2018-07-23T16:57:36.000Z | geodj/genre_parser.py | teopeurt/GeoDJ | 2bc7da9f10ea17ed22565fb9cad197601cce950d | [
"MIT"
]
| null | null | null | geodj/genre_parser.py | teopeurt/GeoDJ | 2bc7da9f10ea17ed22565fb9cad197601cce950d | [
"MIT"
]
| null | null | null | import re
from django.utils.encoding import smart_str
class GenreParser:
@staticmethod
def parse(genre):
genre = smart_str(genre).lower()
if re.search(r"\b(jazz|blues)\b", genre):
return "jazz"
if re.search(r"\b(ska|reggae|ragga|dub)\b", genre):
return "ska"
elif re.search(r"\b(r&b|funk|soul)\b", genre):
return "r&b"
elif re.search(r"\bfolk\b", genre):
return "folk"
elif re.search(r"\b(country|bluegrass)\b", genre):
return "country"
elif re.search(r"\b(rap|hip hop|crunk|trip hop)\b", genre):
return "hiphop"
elif re.search(r"\bpop\b", genre):
return "pop"
elif re.search(r"\b(rock|metal|punk)\b", genre):
return "rock"
elif re.search(r"\b(electronic|electronica|electro|house|techno|ambient|chiptune|industrial|downtempo|drum and bass|trance|dubstep)\b", genre):
return "electronic"
elif re.search(r"\b(classical|orchestra|opera|piano|violin|cello)\b", genre):
return "classical"
| 39.357143 | 151 | 0.588022 |
3d7c1c2950009fc1a152d2059faaa2389e7ac3e7 | 19,373 | py | Python | concil/image.py | ruema/concil | da6b0aa8297addbf003f3670050256a5ee7e3c70 | [
"MIT"
]
| 3 | 2020-11-09T06:53:26.000Z | 2022-02-23T22:07:15.000Z | concil/image.py | ruema/concil | da6b0aa8297addbf003f3670050256a5ee7e3c70 | [
"MIT"
]
| null | null | null | concil/image.py | ruema/concil | da6b0aa8297addbf003f3670050256a5ee7e3c70 | [
"MIT"
]
| null | null | null | import os
import json
import tempfile
import base64
import gzip
import subprocess
import shutil
import io
from hashlib import sha256, sha512
from pathlib import Path
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes, hmac
from jwcrypto import jwk, jwe
from jwcrypto.common import base64url_decode, base64url_encode
from .store import IMAGE_CONVERTERS
from .dockerhub import DockerHub
class FormatError(Exception):
pass
def encode_base64(bytes):
return base64.encodebytes(bytes).strip().decode('ASCII')
def calculate_digest(filename):
hash = sha256()
with filename.open('rb') as input:
while True:
data = input.read(1024*1024)
if not data:
break
hash.update(data)
digest = hash.hexdigest()
return f"sha256:{digest}"
def calculate_gziped_digest(filename):
hash = sha256()
with gzip.open(filename, 'rb') as input:
while True:
data = input.read(1024*1024)
if not data:
break
hash.update(data)
digest = hash.hexdigest()
return f"sha256:{digest}"
DEFAULT_ALGS = {
"EC": "ECDH-ES+A256KW",
"RSA": "RSA-OAEP",
}
def encrypt(input_stream, encrypted_filename):
backend = default_backend()
symkey = os.urandom(32)
nonce = os.urandom(16)
cipher = Cipher(algorithms.AES(symkey), modes.CTR(nonce), backend=backend)
encryptor = cipher.encryptor()
hmac_hash = hmac.HMAC(symkey, hashes.SHA256(), backend=default_backend())
sha_hash_encrypted = sha256()
sha_hash_unencrypted = sha256()
with input_stream, encrypted_filename.open('wb') as output:
while True:
data = input_stream.read(1024*1024)
if not data:
break
sha_hash_unencrypted.update(data)
data = encryptor.update(data)
sha_hash_encrypted.update(data)
hmac_hash.update(data)
output.write(data)
data = encryptor.finalize()
sha_hash_encrypted.update(data)
hmac_hash.update(data)
output.write(data)
hmac_hash = hmac_hash.finalize()
sha_hash_encrypted = sha_hash_encrypted.hexdigest()
sha_hash_unencrypted = sha_hash_unencrypted.hexdigest()
pub_data = {
"cipher": "AES_256_CTR_HMAC_SHA256",
"hmac": encode_base64(hmac_hash),
"cipheroptions": {}
}
payload = {
"symkey": encode_base64(symkey),
"digest": f"sha256:{sha_hash_unencrypted}",
"cipheroptions": {"nonce": encode_base64(nonce)}
}
return pub_data, payload, sha_hash_encrypted
class _Stream:
def __init__(self):
self.buf = b""
self.pos = 0
self.closed = False
def tell(self):
return self.pos
def write(self, buf):
self.buf += buf
def close(self):
self.closed = True
class MergedIO:
def __init__(self, fileobjects):
self.stream = _Stream()
self.processor = self.process(fileobjects)
def process(self, fileobjects):
seen = set()
output = TarFile.open(fileobj=stream, mode="w:")
for fileobject in fileobjects:
tarfile = Tarfile.open(fileobj=fileobject, mode="r|")
for info in tarfile:
output.addfile(self, info)
yield
if info.sparse is not None:
size = sum(size for offset, size in info.sparse)
else:
size = tarinfo.size
blocks = (size + BLOCKSIZE - 1) // BLOCKSIZE
while blocks > 0:
cnt = 32 if blocks > 32 else blocks
buf = tarfile.fileobj.read(cnt * BLOCKSIZE)
output.fileobj.write(buf)
yield
blocks -= cnt
output.close()
stream.close()
yield
def read(self, length):
while len(self.stream.buf) < length:
if self.stream.closed:
break
next(self.processor)
buf = self.stream.buf
result = buf[:length]
self.stream.buf = buf[length:]
return result
def __enter__(self):
return self
def __exit__(self, *args):
return
class ZipStream:
def __init__(self, input_stream):
self.input_stream = input_stream
self.buffer = b''
self.finished = False
self.gzipper = gzip.open(self, 'wb')
def write(self, data):
self.buffer += data
def read(self, length):
while not self.finished and len(self.buffer) < length:
buf = self.input_stream.read(10240)
if buf:
self.gzipper.write(buf)
else:
self.finished = True
self.gzipper.close()
buf = self.buffer[:length]
self.buffer = self.buffer[length:]
return buf
def __enter__(self):
return self
def __exit__(self, *args):
return
class Descriptor:
def __init__(self, filename, media_type, digest, annotations=None):
self.filename = filename
self.media_type = media_type
if digest is None:
digest = "dir:xxxxxxxxxxxxxxx" if media_type == "dir" else calculate_digest(filename)
self.digest = digest
self._unpacked_digest = None
self.data = None
self.annotations = annotations if annotations is not None else {}
self.converted_media_type = "tar+gzip" if media_type == "dir" else None
self.encryption_keys = []
self.status = 'keep'
@property
def size(self):
if self.data:
return len(self.data)
return self.filename.stat().st_size
@property
def unpacked_digest(self):
if self._unpacked_digest is None:
if self.media_type == 'squashfs':
self._unpacked_digest = self.digest
elif self.media_type == 'tar':
self._unpacked_digest = self.digest
elif self.media_type == 'tar+gzip':
self._unpacked_digest = calculate_gziped_digest(self.filename)
elif self.media_type.endswith('+encrypted'):
self._unpacked_digest = self.digest
elif self.media_type == "dir":
self._unpacked_digest = self.digest
else:
raise RuntimeError(self.media_type)
return self._unpacked_digest
def convert(self, media_type):
if self.media_type != media_type:
self.converted_media_type = media_type
@classmethod
def from_data(cls, data, media_type, annotations=None):
hash = sha256(data).hexdigest()
digest = f"sha256:{hash}"
result = cls(None, media_type, digest, annotations)
if media_type in ("tar+gzip", "tar+zstd"):
raise NotImplemented()
else:
result._unpacked_digest = digest
result.data = data
return result
def as_tar_stream(self):
if self.media_type == 'squashfs':
raise NotImplemented()
if self.media_type == 'dir':
import tarfile
stream = io.BytesIO()
tar = tarfile.open(fileobj=stream, mode="w")
tar.add(self.filename, arcname='/')
stream.seek(0)
return stream
elif self.data:
stream = io.BytesIO(self.data)
else:
stream = self.filename.open('rb')
if self.media_type == 'tar':
return stream
if self.media_type == 'tar+gzip':
return gzip.open(stream, 'rb')
raise NotImplemented()
def export(self, path, merge_with=None):
if self.converted_media_type is None and not self.encryption_keys and not merge_with:
if self.data:
input_stream = io.BytesIO(self.data)
else:
input_stream = self.filename.open('rb')
print(f"Copy {self.digest} ({self.media_type})")
output_filename = path / self.digest.split(':', 1)[1]
with input_stream, output_filename.open('wb') as output:
shutil.copyfileobj(input_stream, output)
return type(self)(output_filename, self.media_type, self.digest, self.annotations)
media_type = self.converted_media_type or self.media_type
temporary_file = None
if merge_with:
input_stream = MergedIO([self.as_tar_stream()] + [m.as_tar_stream() for m in merge_with])
else:
input_stream = self.as_tar_stream()
if media_type in ['tar+gzip', 'tar']:
if media_type == 'tar+gzip':
input_stream = ZipStream(input_stream)
if not self.encryption_keys:
print(f"Copy {self.digest} ({self.media_type})")
temp_filename = path / "temp"
with input_stream, temp_filename.open('wb') as output:
shutil.copyfileobj(input_stream, output)
digest = calculate_digest(temp_filename)
output_filename = path / digest.split(':', 1)[1]
temp_filename.rename(output_filename)
return type(self)(output_filename, media_type, digest, self.annotations)
elif media_type == "squashfs":
print(f"Convert {self.digest}: {self.media_type} -> {self.converted_media_type}")
convert = IMAGE_CONVERTERS.get('tar')
if convert is None:
raise NotImplemented()
squash_filename = path / f"{self.digest}.sq"
diff_digest = convert(input_stream, squash_filename)
self._unpacked_digest = f"sha256:{diff_digest}"
if not self.encryption_keys:
digest = calculate_digest(squash_filename)
output_filename = squash_filename.with_name(digest.split(':',1)[1])
squash_filename.rename(output_filename)
return type(self)(output_filename, self.converted_media_type, digest, self.annotations)
else:
temporary_file = squash_filename
input_stream = squash_filename.open('rb')
else:
raise NotImplemented()
assert self.encryption_keys
print(f"Encrypt {self.digest}")
encrypted_filename = path / "enc"
pub_data, payload, sha_hash_encrypted = encrypt(input_stream, encrypted_filename)
jwetoken = jwe.JWE(json.dumps(payload).encode('utf-8'),
protected={"enc": "A256GCM"},
)
for key in self.encryption_keys:
jwetoken.add_recipient(key, header={"alg": DEFAULT_ALGS[key.key_type]})
enc = jwetoken.serialize()
annotations = dict(self.annotations, **{
"org.opencontainers.image.enc.keys.jwe": base64url_encode(enc),
"org.opencontainers.image.enc.pubopts": base64url_encode(json.dumps(pub_data)),
})
output_filename = path / sha_hash_encrypted
encrypted_filename.rename(output_filename)
if temporary_file is not None:
temporary_file.unlink()
result = type(self)(output_filename, media_type + "+encrypted",
f"sha256:{sha_hash_encrypted}",
annotations)
result._unpacked_digest = result.digest
return result
def read(self):
if self.data:
return self.data
return self.filename.read_bytes()
class ImageManifest:
DIRECTORY_TRANSPORT = "Directory Transport Version: 1.1\n"
MANIFEST_DOCKER_MEDIA_TYPE = "application/vnd.docker.distribution.manifest.v2+json"
MANIFEST_OCI_MEDIA_TYPE = "application/vnd.oci.image.manifest.v1+json"
MEDIA_TYPES = {
MANIFEST_OCI_MEDIA_TYPE: {
"config": "application/vnd.oci.image.config.v1+json",
"tar": "application/vnd.oci.image.layer.v1.tar",
"tar+gzip": "application/vnd.oci.image.layer.v1.tar+gzip",
"tar+zstd": "application/vnd.oci.image.layer.v1.tar+zstd",
"tar+encrypted": "application/vnd.oci.image.layer.v1.tar+encrypted",
"tar+gzip+encrypted": "application/vnd.oci.image.layer.v1.tar+gzip+encrypted",
"tar+zstd+encrypted": "application/vnd.oci.image.layer.v1.tar+zstd+encrypted",
"squashfs": "application/vnd.oci.image.layer.v1.squashfs",
"squashfs+encrypted": "application/vnd.oci.image.layer.v1.squashfs+encrypted",
},
MANIFEST_DOCKER_MEDIA_TYPE: {
"config": "application/vnd.docker.container.image.v1+json",
"tar": "application/vnd.docker.image.rootfs.diff.tar",
"tar+gzip": "application/vnd.docker.image.rootfs.diff.tar.gzip",
"tar+zstd": "application/vnd.docker.image.rootfs.diff.tar.zstd",
"tar+encrypted": "application/vnd.docker.image.rootfs.diff.tar+encrypted",
"tar+gzip+encrypted": "application/vnd.docker.image.rootfs.diff.tar.gzip+encrypted",
"tar+zstd+encrypted": "application/vnd.docker.image.rootfs.diff.tar.zstd+encrypted",
"squashfs": "application/vnd.docker.image.rootfs.diff.squashfs",
"squashfs+encrypted": "application/vnd.docker.image.rootfs.diff.squashfs+encrypted",
}
}
_REVERSED_MEDIA_TYPES = {
key: value for types in MEDIA_TYPES.values() for value, key in types.items()
}
def __init__(self, path, manifest_format=None):
self.path = path
self.schema_version = 2
self.manifest_format = manifest_format if manifest_format is not None else self.MANIFEST_DOCKER_MEDIA_TYPE
self.config = None
self.layers = []
self.annotations = {}
@classmethod
def _make_descriptor(cls, path, meta):
media_type = meta['mediaType']
media_type = cls._REVERSED_MEDIA_TYPES.get(media_type, media_type)
digest = meta['digest']
annotations = meta.get('annotations', {})
filename = path / digest.split(':', 1)[1]
return Descriptor(filename, media_type, digest, annotations)
@classmethod
def from_path(cls, path):
path = Path(path)
if (path / "index.json").exists():
with (path / "index.json").open('rb') as index:
index = json.load(index)
manifests = index.get('manifests', [])
if len(manifests) != 1:
raise RuntimeError("unsupported")
manifest_file = Path(path, "blobs", *manifests[0]['digest'].split(':'))
path = manifest_file.parent
else:
manifest_file = path / "manifest.json"
with manifest_file.open('rb') as manifest:
manifest = json.load(manifest)
if manifest.get("schemaVersion") != 2:
raise FormatError("unkown schema version")
media_type = manifest.get("mediaType", cls.MANIFEST_OCI_MEDIA_TYPE)
result = cls(path, media_type)
result.config = cls._make_descriptor(path, manifest["config"])
result.layers = [
cls._make_descriptor(path, layer)
for layer in manifest["layers"]
]
result.annotations = manifest.get('annotations',{})
return result
def _descriptor_to_dict(self, manifest_format, descriptor):
media_type = descriptor.media_type
result = {
"mediaType": self.MEDIA_TYPES[manifest_format].get(media_type, media_type),
"size": descriptor.size,
"digest": descriptor.digest,
}
if descriptor.annotations:
result["annotations"] = descriptor.annotations
return result
def export(self, path, manifest_format=None):
path = Path(path)
path.mkdir()
if manifest_format is None:
manifest_format = self.manifest_format
export_layers = []
new_diffs = []
digests = {}
for layer in self.layers:
digest = layer.unpacked_digest
if layer.status == 'remove':
new_digest = None
else:
if layer.status == 'merge':
exported = layer.export(path, layer.merge_with)
else:
exported = layer.export(path)
new_digest = exported.unpacked_digest
export_layers.append(exported)
if layer.status == 'new':
new_diffs.append(new_digest)
digests[digest] = new_digest
config = json.loads(self.config.read())
config['rootfs']['diff_ids'] = [
digests[digest]
for digest in config['rootfs']['diff_ids']
if digests[digest] is not None
] + new_diffs
config = Descriptor.from_data(json.dumps(config).encode('utf8'), "config")
manifest = {
"schemaVersion":2,
}
if manifest_format != self.MANIFEST_OCI_MEDIA_TYPE:
manifest["mediaType"] = manifest_format
manifest['config'] = self._descriptor_to_dict(manifest_format, config.export(path))
manifest['layers'] = [
self._descriptor_to_dict(manifest_format, layer)
for layer in export_layers
]
with (path / "manifest.json").open("w", encoding="utf8") as output:
json.dump(manifest, output)
with (path / "version").open("w", encoding="utf8") as output:
output.write(self.DIRECTORY_TRANSPORT)
def publish(self, docker_url, manifest_format=None, root_certificate=None):
from .store import Store
from .notary import generate_hashes
if manifest_format is None:
manifest_format = self.manifest_format
manifest = {
"schemaVersion":2,
}
if manifest_format != self.MANIFEST_OCI_MEDIA_TYPE:
manifest["mediaType"] = manifest_format
manifest['config'] = self._descriptor_to_dict(manifest_format, self.config)
manifest['layers'] = [
self._descriptor_to_dict(manifest_format, layer)
for layer in self.layers
]
store = Store(docker_url)
hub = store._hub
for layer in self.layers:
if hub.has_blob(layer.digest):
print(f"Blob {layer.digest} found.")
else:
print(f"Blob {layer.digest} uploading...")
hub.post_blob(str(layer.filename))
print("finished.")
if hub.has_blob(self.config.digest):
print(f"Config {self.config.digest} found.")
else:
print(f"Config {self.config.digest} uploading...")
hub.post_blob(str(self.config.filename))
print("finished.")
print("Writing manifest to image destination.")
data = json.dumps(manifest).encode()
hub.post_manifest(data)
sha256_digest = sha256(data).hexdigest()
sha512_digest = sha512(data).hexdigest()
print(f"{len(data)} --sha256 {sha256_digest} --sha512 {sha512_digest}")
notary = store._notary
if notary is not None:
hashes = generate_hashes(data)
notary.add_target_hashes(store.url.tag, hashes)
notary.publish(root_certificate)
| 37.911937 | 114 | 0.599288 |
b0c0a2ed76ea1d7c31d6387f912d7c42e56ac0f4 | 1,858 | py | Python | dev/python/2018-09-01 stim class redesign.py | konung-yaropolk/pyABF | b5620e73ac5d060129b844da44f8b2611536ac56 | [
"MIT"
]
| 74 | 2017-11-06T17:53:48.000Z | 2022-03-27T12:14:46.000Z | dev/python/2018-09-01 stim class redesign.py | konung-yaropolk/pyABF | b5620e73ac5d060129b844da44f8b2611536ac56 | [
"MIT"
]
| 116 | 2018-01-16T21:36:29.000Z | 2022-03-31T11:46:04.000Z | dev/python/2018-09-01 stim class redesign.py | konung-yaropolk/pyABF | b5620e73ac5d060129b844da44f8b2611536ac56 | [
"MIT"
]
| 30 | 2018-06-28T13:19:53.000Z | 2022-03-25T02:52:48.000Z | """
see if a simpler stimulus class can be designed
"""
import os
import sys
PATH_HERE = os.path.abspath(os.path.dirname(__file__))
PATH_DATA = os.path.abspath(PATH_HERE+"../../../data/abfs/")
PATH_SRC = os.path.abspath(PATH_HERE+"../../../src/")
sys.path.insert(0, PATH_SRC)
import pyabf
import glob
import numpy as np
import matplotlib.pyplot as plt
import logging
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
class Epoch:
def __init__(self, abf):
"""
A simple wrapper for
"""
assert isinstance(abf, pyabf.ABF)
if abf.abfVersion["major"]==1:
self._readV1()
else:
self._readV2()
def _readV1(self):
"""ABF v1 does not support epoch waveforms."""
self.points = []
self.values = []
self.digitalWaveform = []
def _readV2(self):
"""Prepare epoch points and values from the epoch table."""
points = pyabf.stimulus.epochPoints(abf)
values = list(pyabf.stimulus.epochValues(abf)[abf.sweepNumber])
# add an extra point for the beginning of the sweep
points = [0]+points
values = [abf.sweepC[0]]+values
# add extra points for the end of the sweep
points.append(abf.sweepPointCount)
while (len(values)<len(points)):
values.append(abf.sweepC[-1])
self.points = points
self.values = values
# prepare digital waveform
digitalWaveforms = pyabf.stimulus.digitalWaveformEpochs(abf)
self.digital = digitalWaveforms[abf.sweepNumber]
if __name__ == "__main__":
for fname in glob.glob(PATH_DATA+"/*.abf"):
print(fname)
abf = pyabf.ABF(fname)
for sweep in range(min(3, abf.sweepCount)):
abf.setSweep(sweep)
epochs = Epoch(abf)
print("DONE")
| 26.927536 | 71 | 0.614639 |
d8549f9b91e11b983fae2416aa0c3afbd2946ff4 | 309 | py | Python | Simple Django Project/comment8or/admin.py | petrenkonikita112263/Python_Professional_Portfolio_Projects | 60180daf163067851886ee49aea810bc09bd8bee | [
"MIT"
]
| 1 | 2021-09-13T00:54:29.000Z | 2021-09-13T00:54:29.000Z | Simple Django Project/comment8or/admin.py | petrenkonikita112263/Python_Professional_Portfolio_Projects | 60180daf163067851886ee49aea810bc09bd8bee | [
"MIT"
]
| null | null | null | Simple Django Project/comment8or/admin.py | petrenkonikita112263/Python_Professional_Portfolio_Projects | 60180daf163067851886ee49aea810bc09bd8bee | [
"MIT"
]
| null | null | null | from django.contrib import admin
class Comment8orAdminSite(admin.AdminSite):
"""Custom admin site for Comment8or application."""
title_header = "c8 site admin"
site_header = "Comment8or administration"
index_title = "Comment8or site admin"
logout_template = "comment8or/logged_out.html"
| 30.9 | 55 | 0.750809 |
82e6597da25277e90edc5910bfae026c4afc9d25 | 4,819 | py | Python | SHM prototype/inputTime.py | acharaakshit/Structural-Health-Monitoring | 51c0dc935eb7c361252f7416a860bd7be73361c4 | [
"MIT"
]
| 1 | 2019-05-26T06:31:59.000Z | 2019-05-26T06:31:59.000Z | SHM prototype/inputTime.py | acharaakshit/Structural-Health-Monitoring | 51c0dc935eb7c361252f7416a860bd7be73361c4 | [
"MIT"
]
| null | null | null | SHM prototype/inputTime.py | acharaakshit/Structural-Health-Monitoring | 51c0dc935eb7c361252f7416a860bd7be73361c4 | [
"MIT"
]
| 1 | 2018-11-12T10:59:38.000Z | 2018-11-12T10:59:38.000Z | # -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'inputTime.ui'
#
# Created by: PyQt4 UI code generator 4.12.1
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
import FFT_inputTime
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
try:
_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig)
class Ui_InputTime_FFT(object):
def messagePoint(self):
self.temp_messageBox= QtGui.QMessageBox()
self.temp_messageBox.setInformativeText("One of the Input values havent been entered. Please enter them all")
self.temp_messageBox.setStandardButtons(QtGui.QMessageBox.Ok)
ret = self.temp_messageBox.exec_()
if(ret == QtGui.QMessageBox.Yes):
return
def checkPoint(self):
if(self.lineEdit.text() == "" or self.lineEdit_2.text() == "" or self.lineEdit_3.text() == "" or self.lineEdit_4.text() == ""):
self.messagePoint()
return
else:
#print(self.lineEdit.text(), " ", self.lineEdit_2.text(), " ", self.lineEdit_3.text(), " ", self.lineEdit_4.text())
FFT_inputTime.main(self.lineEdit.text(), self.lineEdit_2.text(),self.lineEdit_3.text(), self.lineEdit_4.text())
def setupUi(self, InputTime_FFT):
InputTime_FFT.setObjectName(_fromUtf8("InputTime_FFT"))
InputTime_FFT.resize(530, 300)
self.widget = QtGui.QWidget(InputTime_FFT)
self.widget.setGeometry(QtCore.QRect(10, 70, 455, 173))
self.widget.setObjectName(_fromUtf8("widget"))
self.formLayout = QtGui.QFormLayout(self.widget)
self.formLayout.setMargin(0)
self.formLayout.setObjectName(_fromUtf8("formLayout"))
self.gridLayout = QtGui.QGridLayout()
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.label = QtGui.QLabel(self.widget)
self.label.setObjectName(_fromUtf8("label"))
self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
self.label_2 = QtGui.QLabel(self.widget)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
self.label_3 = QtGui.QLabel(self.widget)
self.label_3.setObjectName(_fromUtf8("label_3"))
self.gridLayout.addWidget(self.label_3, 2, 0, 1, 2)
self.lineEdit_3 = QtGui.QLineEdit(self.widget)
self.lineEdit_3.setObjectName(_fromUtf8("lineEdit_3"))
self.gridLayout.addWidget(self.lineEdit_3, 2, 2, 1, 1)
self.label_4 = QtGui.QLabel(self.widget)
self.label_4.setObjectName(_fromUtf8("label_4"))
self.gridLayout.addWidget(self.label_4, 3, 0, 1, 2)
self.lineEdit_4 = QtGui.QLineEdit(self.widget)
self.lineEdit_4.setObjectName(_fromUtf8("lineEdit_4"))
self.gridLayout.addWidget(self.lineEdit_4, 3, 2, 1, 1)
self.lineEdit = QtGui.QLineEdit(self.widget)
self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
self.gridLayout.addWidget(self.lineEdit, 0, 2, 1, 1)
self.lineEdit_2 = QtGui.QLineEdit(self.widget)
self.lineEdit_2.setObjectName(_fromUtf8("lineEdit_2"))
self.gridLayout.addWidget(self.lineEdit_2, 1, 2, 1, 1)
self.formLayout.setLayout(0, QtGui.QFormLayout.LabelRole, self.gridLayout)
self.pushButton = QtGui.QPushButton(self.widget)
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.formLayout.setWidget(1, QtGui.QFormLayout.LabelRole, self.pushButton)
self.retranslateUi(InputTime_FFT)
QtCore.QMetaObject.connectSlotsByName(InputTime_FFT)
def retranslateUi(self, InputTime_FFT):
InputTime_FFT.setWindowTitle(_translate("InputTime_FFT", "Form", None))
self.label.setText(_translate("InputTime_FFT", "Enter Name of the sensor used", None))
self.label_2.setText(_translate("InputTime_FFT", "Enter Path of the file", None))
self.label_3.setText(_translate("InputTime_FFT", "Enter the time period for which given data is collected", None))
self.label_4.setText(_translate("InputTime_FFT", "Enter the sampling rate for which FFT is to be done", None))
self.pushButton.setText(_translate("InputTime_FFT", "OK", None))
self.pushButton.clicked.connect(self.checkPoint)
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
InputTime_FFT = QtGui.QWidget()
ui = Ui_InputTime_FFT()
ui.setupUi(InputTime_FFT)
InputTime_FFT.show()
sys.exit(app.exec_())
| 45.037383 | 135 | 0.687902 |
ceade3e4f8b87656052ab2924cccc6407c414d11 | 1,519 | py | Python | tests/bugs/core_3737_test.py | FirebirdSQL/firebird-qa | 96af2def7f905a06f178e2a80a2c8be4a4b44782 | [
"MIT"
]
| 1 | 2022-02-05T11:37:13.000Z | 2022-02-05T11:37:13.000Z | tests/bugs/core_3737_test.py | FirebirdSQL/firebird-qa | 96af2def7f905a06f178e2a80a2c8be4a4b44782 | [
"MIT"
]
| 1 | 2021-09-03T11:47:00.000Z | 2021-09-03T12:42:10.000Z | tests/bugs/core_3737_test.py | FirebirdSQL/firebird-qa | 96af2def7f905a06f178e2a80a2c8be4a4b44782 | [
"MIT"
]
| 1 | 2021-06-30T14:14:16.000Z | 2021-06-30T14:14:16.000Z | #coding:utf-8
#
# id: bugs.core_3737
# title: EXECUTE BLOCK parameters definitions are not respected and may cause wrong behavior related to character sets
# decription:
# tracker_id: CORE-3737
# min_versions: ['3.0']
# versions: 3.0
# qmid: None
import pytest
from firebird.qa import db_factory, isql_act, Action
# version: 3.0
# resources: None
substitutions_1 = []
init_script_1 = """"""
db_1 = db_factory(sql_dialect=3, init=init_script_1)
test_script_1 = """
set list on;
set term ^;
execute block returns(len_1252 int, len_utf8 int) as
declare s varchar(16) character set utf8 = 'ÃÂÁÀÄÅÇØßÐÑÞÆŠŒŽ'; -- http://en.wikipedia.org/wiki/Windows-1252
begin
execute statement (
'execute block (c varchar(16) character set win1252 = ?) returns (n int) as '
|| 'begin '
|| ' n = octet_length(c); '
|| ' suspend; '
|| 'end') (s)
into len_1252;
execute statement (
'execute block (c varchar(16) character set utf8 = ?) returns (n int) as '
|| 'begin '
|| ' n = octet_length(c); '
|| ' suspend; '
|| 'end') (s)
into len_utf8;
suspend;
end
^
set term ;^
commit;
"""
act_1 = isql_act('db_1', test_script_1, substitutions=substitutions_1)
expected_stdout_1 = """
LEN_1252 16
LEN_UTF8 32
"""
@pytest.mark.version('>=3.0')
def test_1(act_1: Action):
act_1.expected_stdout = expected_stdout_1
act_1.execute()
assert act_1.clean_stdout == act_1.clean_expected_stdout
| 23.369231 | 125 | 0.637261 |
f105573b3c94ac7e6c0561f0b4de0d08a012b50b | 7,950 | py | Python | ipython_histories/avagraph3.py | teolisitza/turtleart | 925423ccaebede0a347a7182ae0aa61fe686ccc3 | [
"Apache-2.0"
]
| null | null | null | ipython_histories/avagraph3.py | teolisitza/turtleart | 925423ccaebede0a347a7182ae0aa61fe686ccc3 | [
"Apache-2.0"
]
| 1 | 2017-02-06T22:02:28.000Z | 2017-02-06T22:02:28.000Z | ipython_histories/avagraph3.py | teolisitza/turtleart | 925423ccaebede0a347a7182ae0aa61fe686ccc3 | [
"Apache-2.0"
]
| null | null | null | Last login: Mon Mar 30 19:49:46 on ttys000
MBPro ~> cd kids_sessions/
MBPro kids_sessions> ls
ava.eps ava_3_3_15.out ava_graph2.out
ava2.eps ava_advanced.png avagraph.out
ava3.eps ava_graph.eps avagraph2.out
ava4.eps ava_graph.png cohen_crazy_square.out
MBPro kids_sessions> mkdir packages
MBPro kids_sessions> cd packages/
MBPro packages> vim avaturtle.py
MBPro packages> cd ..
MBPro kids_sessions> ls
ava.eps ava_advanced.png avagraph2.out
ava2.eps ava_graph.eps cohen_crazy_square.out
ava3.eps ava_graph.png packages
ava4.eps ava_graph2.out
ava_3_3_15.out avagraph.out
MBPro kids_sessions> PYTHONPATH=`pwd`/packages ipython
Python 2.7.5 (default, Mar 9 2014, 22:15:05)
Type "copyright", "credits" or "license" for more information.
IPython 2.3.0 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.
In [1]: import avaturtle
In [2]: avaturtle.drawline?
Type: function
String form: <function drawline at 0x10d860578>
File: /Users/teo/kids_sessions/packages/avaturtle.py
Definition: avaturtle.drawline(turt, a, b, c, d)
Docstring: <no docstring>
In [3]: import turtle
In [4]: ava = turtle.Turtle()
In [5]: avaturtle.drawline(ava, 0,0, 30,30)
In [6]: ava.un
ava.undo ava.undobuffer ava.undobufferentries
In [6]: ava.undo()
In [7]: def makegraph(turt):
...: turt.drawline(-1000, 0, 1000, 0)
...: turt.drawline
...:
In [8]: def makegraph(turt):
KeyboardInterrupt
In [8]: def makegraph(turt):
...: avaturtle.drawline(turt, -1000, 0, 1000, 0)
...: avaturtle.drawline(turt, 0, -1000, 0, 1000)
...:
In [9]: ava.speed(10)
In [10]: makegraph(ava)
In [11]: edit packages/
packages/avaturtle.py packages/avaturtle.pyc
In [11]: edit packages/avaturtle.py
Editing... done. Executing edited code...
In [12]:
Do you really want to exit ([y]/n)?
MBPro kids_sessions> PYTHONPATH=`pwd`/packages ipython
Python 2.7.5 (default, Mar 9 2014, 22:15:05)
Type "copyright", "credits" or "license" for more information.
IPython 2.3.0 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.
In [1]: import turtle
In [2]: ava = turtle.Turtle()
In [3]: from avaturtle import *
In [4]: makegraph()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-4-7486f9b0e4a1> in <module>()
----> 1 makegraph()
TypeError: makegraph() takes exactly 1 argument (0 given)
In [5]: makegraph(ava)
In [6]: ava.goto(0,0)
In [7]: edit packages/avaturtle.py
Editing... done. Executing edited code...
In [8]: reload(ava
ava ava3.eps ava_advanced.png ava_graph2.out
ava.eps ava4.eps ava_graph.eps avagraph.out
ava2.eps ava_3_3_15.out ava_graph.png avagraph2.out
In [8]:
Do you really want to exit ([y]/n)?
MBPro kids_sessions> PYTHONPATH=`pwd`/packages ipython
Python 2.7.5 (default, Mar 9 2014, 22:15:05)
Type "copyright", "credits" or "license" for more information.
IPython 2.3.0 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.
In [1]: import turtle
In [2]: ava = turtle.Turtle()
In [3]: ava.speed(10)
In [4]: import avaturtle
In [5]: avaturtle.makegraph()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-5-5ec8fa0eaee0> in <module>()
----> 1 avaturtle.makegraph()
TypeError: makegraph() takes exactly 1 argument (0 given)
In [6]: avaturtle.makegraph(ava)
In [7]: avaturtle.dr
avaturtle.draw_quad avaturtle.drawline
In [7]: avaturtle.draw_quad(ava)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-7-e52f6c9a2855> in <module>()
----> 1 avaturtle.draw_quad(ava)
/Users/teo/kids_sessions/packages/avaturtle.py in draw_quad(turt)
13 y = -200
14 while x <= 200:
---> 15 drawline(x, 0,0,y)
16 x += 20
17 y += 20
TypeError: drawline() takes exactly 5 arguments (4 given)
In [8]: edit packages/avaturtle.py
Editing... done. Executing edited code...
In [9]: reload(avaturtle)
Out[9]: <module 'avaturtle' from '/Users/teo/kids_sessions/packages/avaturtle.py'>
In [10]: avaturtle.draw_quad(ava)
In [11]: avaturtle.draw_quad(ava)
In [12]: avaturtle.draw_quad(ava)
In [13]: edit packages/avaturtle.py
Editing... done. Executing edited code...
In [14]: reload(avaturtle)
Out[14]: <module 'avaturtle' from '/Users/teo/kids_sessions/packages/avaturtle.py'>
In [15]: avaturtle.draw_quad(ava)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-15-e52f6c9a2855> in <module>()
----> 1 avaturtle.draw_quad(ava)
TypeError: draw_quad() takes exactly 2 arguments (1 given)
In [16]: edit packages/avaturtle.py
Editing... done. Executing edited code...
In [17]: avaturtle.draw_quad(ava,20)
In [18]: avaturtle.draw_quad?
Type: function
String form: <function draw_quad at 0x1072685f0>
File: /Users/teo/kids_sessions/packages/avaturtle.py
Definition: avaturtle.draw_quad(turt, size)
Docstring: <no docstring>
In [19]: avaturtle.draw_quad??
Type: function
String form: <function draw_quad at 0x1072685f0>
File: /Users/teo/kids_sessions/packages/avaturtle.py
Definition: avaturtle.draw_quad(turt, size)
Source:
def draw_quad(turt, size):
x = size
y = -(size*10)
while x <= 200:
drawline(turt, x, 0,0,y)
x += 20
y += 20
In [20]: avaturtle.draw_quad(ava,30)
In [21]: avaturtle.draw_quad(ava,20)
In [22]: avaturtle.draw_quad(ava,10)
In [23]: avaturtle.draw_quad(ava,5)
In [24]: edit packages/avaturtle.py
Editing... done. Executing edited code...
In [25]: ava.undo
ava.undo ava.undobuffer ava.undobufferentries
In [25]: ava.undo()
In [26]: ava.undo()
In [27]: ava.undo()
In [28]: ava.undo()
In [29]: ava.undo()
In [30]: ava.undo()
In [31]: while True:
....: ava.und()
....: ava.undo()
KeyboardInterrupt
In [31]: while True:
ava.undo()
....:
^C---------------------------------------------------------------------------
KeyboardInterrupt Traceback (most recent call last)
<ipython-input-31-5b11be272e76> in <module>()
1 while True:
----> 2 ava.undo()
3
/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-tk/turtle.pyc in undo(self)
3529 if self.undobuffer is None:
3530 return
-> 3531 item = self.undobuffer.pop()
3532 action = item[0]
3533 data = item[1:]
/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-tk/turtle.pyc in pop(self)
898 return None
899 else:
--> 900 self.buffer[self.ptr] = [None]
901 self.ptr = (self.ptr - 1) % self.bufsize
902 return (item)
KeyboardInterrupt:
In [32]: edit packages/avaturtle.py
Editing... done. Executing edited code...
In [33]: avaturtle.draw_quad(ava,50)
In [34]: avaturtle.draw_quad(ava,20)
In [35]: avaturtle.makegraph(ava)
| 28.804348 | 102 | 0.617862 |
a05be0718b137f679f40f707035c2dd4721ab58d | 123 | py | Python | declare_qtquick/widgets/api/qt/labs/platform/__init__.py | likianta/declare-qtquick | 93c2ce49d841ccdeb0272085c5f731139927f0d7 | [
"MIT"
]
| 3 | 2021-11-02T03:45:27.000Z | 2022-03-27T05:33:36.000Z | declare_qtquick/widgets/api/qt/labs/platform/__init__.py | likianta/declare-qtquick | 93c2ce49d841ccdeb0272085c5f731139927f0d7 | [
"MIT"
]
| null | null | null | declare_qtquick/widgets/api/qt/labs/platform/__init__.py | likianta/declare-qtquick | 93c2ce49d841ccdeb0272085c5f731139927f0d7 | [
"MIT"
]
| null | null | null | from __declare_qtquick_internals__ import qml_imports
qml_imports.add("Qt.labs.platform")
from .__list__ import * # noqa
| 24.6 | 53 | 0.813008 |
3ec0cec4e93bbe623670435f5018ff132cd707b3 | 765 | py | Python | cdi/shop/migrations/0005_auto_20210505_2317.py | fouadsan/cdi_web | e443370a65cac6ce729d353e574afa2b74856192 | [
"MIT"
]
| null | null | null | cdi/shop/migrations/0005_auto_20210505_2317.py | fouadsan/cdi_web | e443370a65cac6ce729d353e574afa2b74856192 | [
"MIT"
]
| null | null | null | cdi/shop/migrations/0005_auto_20210505_2317.py | fouadsan/cdi_web | e443370a65cac6ce729d353e574afa2b74856192 | [
"MIT"
]
| null | null | null | # Generated by Django 3.2 on 2021-05-05 22:17
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('shop', '0004_auto_20210505_2317'),
]
operations = [
migrations.AlterField(
model_name='product',
name='brand',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='products', to='shop.brand'),
),
migrations.AlterField(
model_name='product',
name='category',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='products', to='shop.category'),
),
]
| 30.6 | 149 | 0.639216 |
643332bd26fb3bf9777348daad0990b6d4a57eaf | 1,505 | py | Python | recipe_scrapers/tastykitchen.py | B-Evans99/recipe-scrapers | 9c96e91691fe0519967d4d0519be5443b81c30fe | [
"MIT"
]
| null | null | null | recipe_scrapers/tastykitchen.py | B-Evans99/recipe-scrapers | 9c96e91691fe0519967d4d0519be5443b81c30fe | [
"MIT"
]
| null | null | null | recipe_scrapers/tastykitchen.py | B-Evans99/recipe-scrapers | 9c96e91691fe0519967d4d0519be5443b81c30fe | [
"MIT"
]
| null | null | null | from ._abstract import AbstractScraper
from ._utils import get_minutes, normalize_string, get_yields
class TastyKitchen(AbstractScraper):
@classmethod
def host(self):
return 'tastykitchen.com'
def title(self):
return self.soup.find(
'h1',
{'itemprop': 'name'}
).get_text()
def total_time(self):
return sum([
get_minutes(self.soup.find(
'time',
{'itemprop': 'prepTime'})
),
get_minutes(self.soup.find(
'time',
{'itemprop': 'cookTime'})
)
])
def yields(self):
return get_yields(self.soup.find(
'span',
{'itemprop': 'yield'})
)
def image(self):
image = self.soup.find(
'img',
{'class': 'the_recipe_image', 'src': True}
)
return image['src'] if image else None
def ingredients(self):
ingredients = self.soup.find(
'ul',
{'class': "ingredients"}
).findAll('li')
return [
normalize_string(ingredient.get_text())
for ingredient in ingredients
]
def instructions(self):
instructions = self.soup.find(
'span',
{'itemprop': 'instructions'}
).findAll('p')
return '\n'.join([
normalize_string(direction.get_text())
for direction in instructions
])
| 23.515625 | 61 | 0.499668 |
01fe6652347a98ac34b317802ec25d9a9ce70bba | 7,147 | py | Python | src/encoded/tests/test_types_biosample.py | KCL-ORG/encoded | 5a1904e948bfd652e8a8d52c6717d7fc0b56b681 | [
"MIT"
]
| null | null | null | src/encoded/tests/test_types_biosample.py | KCL-ORG/encoded | 5a1904e948bfd652e8a8d52c6717d7fc0b56b681 | [
"MIT"
]
| null | null | null | src/encoded/tests/test_types_biosample.py | KCL-ORG/encoded | 5a1904e948bfd652e8a8d52c6717d7fc0b56b681 | [
"MIT"
]
| null | null | null | import pytest
@pytest.fixture
def human_donor(testapp, award, lab, human):
item = {
'award': award['@id'],
'lab': lab['@id'],
'organism': human['@id'],
}
return testapp.post_json('/human_donor', item).json['@graph'][0]
@pytest.fixture
def mouse_donor(testapp, award, lab, mouse):
item = {
'award': award['@id'],
'lab': lab['@id'],
'organism': mouse['@id'],
}
return testapp.post_json('/mouse_donor', item).json['@graph'][0]
def test_undefined_sex_model_organism(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['sex'] == 'unknown'
def test_undefined_sex_human(testapp, biosample, human):
testapp.patch_json(biosample['@id'], {'organism': human['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['sex'] == 'unknown'
def test_undefined_sex_mouse_with_model_organism_sex_field(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
testapp.patch_json(biosample['@id'], {'model_organism_sex': 'female'})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['sex'] == 'female'
def test_undefined_age_model_organism(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['age'] == 'unknown'
def test_undefined_age_human(testapp, biosample, human):
testapp.patch_json(biosample['@id'], {'organism': human['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['age'] == 'unknown'
def test_undefined_age_mouse_with_model_organism_age_field(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id'],
'model_organism_age': '120',
'model_organism_age_units': 'day'})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['age'] == '120'
def test_undefined_age_units_model_organism(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert 'age_units' not in res.json['object']
def test_undefined_age_units_human(testapp, biosample, human):
testapp.patch_json(biosample['@id'], {'organism': human['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert 'age_units' not in res.json['object']
def test_undefined_age_units_mouse_with_model_organism_age_field(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id'],
'model_organism_age': '120',
'model_organism_age_units': 'day'})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['age_units'] == 'day'
def test_defined_life_stage_human(testapp, biosample, human, human_donor):
testapp.patch_json(biosample['@id'], {'organism': human['@id']})
testapp.patch_json(human_donor['@id'], {'life_stage': 'embryonic'})
testapp.patch_json(biosample['@id'], {'donor': human_donor['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['life_stage'] == 'embryonic'
def test_undefined_life_stage_human(testapp, biosample, human, human_donor):
testapp.patch_json(biosample['@id'], {'organism': human['@id']})
testapp.patch_json(biosample['@id'], {'donor': human_donor['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['life_stage'] == 'unknown'
def test_defined_life_stage_mouse(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
testapp.patch_json(biosample['@id'], {'mouse_life_stage': 'adult'})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['life_stage'] == 'adult'
def test_undefined_life_stage_mouse(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['life_stage'] == 'unknown'
def test_defined_health_status_human(testapp, biosample, human, human_donor):
testapp.patch_json(biosample['@id'], {'organism': human['@id']})
testapp.patch_json(human_donor['@id'], {'health_status': 'healthy'})
testapp.patch_json(biosample['@id'], {'donor': human_donor['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['health_status'] == 'healthy'
def test_defined_health_status_mouse(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
testapp.patch_json(biosample['@id'], {'model_organism_health_status': 'sick'})
res = testapp.get(biosample['@id'] + '@@index-data')
assert res.json['object']['health_status'] == 'sick'
def test_undefined_health_status_mouse(testapp, biosample, mouse):
testapp.patch_json(biosample['@id'], {'organism': mouse['@id']})
res = testapp.get(biosample['@id'] + '@@index-data')
assert 'health_status' not in res.json['object']
def test_biosample_summary(testapp,
donor_1,
biosample_1, treatment):
testapp.patch_json(donor_1['@id'], {'age_units': 'day', 'age': '10', 'sex': 'male', 'life_stage': 'child'})
testapp.patch_json(biosample_1['@id'], {'donor': donor_1['@id'],
"biosample_term_id": "UBERON:0002784",
"biosample_term_name": "liver",
"biosample_type": "tissue",
'treatments': [treatment['@id']]})
res = testapp.get(biosample_1['@id']+'@@index-data')
assert res.json['object']['summary'] == (
'Homo sapiens male child (10 days) liver tissue treated with ethanol')
def test_biosample_summary_construct(testapp,
fly,
fly_donor,
biosample_1,
construct_genetic_modification):
testapp.patch_json(biosample_1['@id'], {
'donor': fly_donor['@id'],
'biosample_term_id': 'UBERON:0002784',
'biosample_term_name': 'liver',
'biosample_type': 'tissue',
'genetic_modifications': [construct_genetic_modification['@id']],
'model_organism_age': '10',
'model_organism_age_units': 'day',
'model_organism_sex': 'female',
'organism': fly['@id']})
res = testapp.get(biosample_1['@id']+'@@index-data')
assert res.json['object']['summary'] == (
'Drosophila melanogaster '
'female (10 days) liver tissue stably expressing C-terminal eGFP-tagged ATF4 under daf-2 promoter')
| 43.054217 | 111 | 0.614104 |
d5c9d13433880f81b26c0e41ac0b5a984698c5b8 | 2,393 | py | Python | dev/profiles/models.py | saurabhrautela/django_boilerplate | a5f6e1d2d444b8a7b0db9eca228a633ce529f5fb | [
"MIT"
]
| null | null | null | dev/profiles/models.py | saurabhrautela/django_boilerplate | a5f6e1d2d444b8a7b0db9eca228a633ce529f5fb | [
"MIT"
]
| 3 | 2019-12-04T22:30:37.000Z | 2021-04-08T18:49:32.000Z | dev/profiles/models.py | saurabhrautela/django_sample | a5f6e1d2d444b8a7b0db9eca228a633ce529f5fb | [
"MIT"
]
| null | null | null | from django.db import models
# `AbstractBaseUser` and `PermissionMixin` are base classes used for customizing the Django User Model
from django.contrib.auth.models import AbstractBaseUser
from django.contrib.auth.models import PermissionsMixin
# `BaseUserManager` is extended by custom user manager to customize how users are created from Django CLI
from django.contrib.auth.models import BaseUserManager
class UserProfileManager(BaseUserManager):
"""Manager for user profiles."""
def create_user(self, email, name, password=None):
"""Create a new user profile."""
if not email:
raise ValueError("User must have an email address.")
# normalize email to change the second half of email to lowercase as it is not case-sensitive
email = self.normalize_email(email)
user = self.model(email=email, name=name)
user.set_password(password)
user.save(using=self._db)
return user
def create_superuser(self, email, name, password):
"""Create and save a new super user with given details."""
user = self.create_user(email=email, name=name, password=password)
user.is_superuser = True
user.is_staff = True
user.save(using=self._db)
return user
class UserProfile(AbstractBaseUser, PermissionsMixin):
"""Database model for user in the system."""
email = models.EmailField(max_length=255, unique=True)
name = models.CharField(max_length=255)
# `is_active` field is used to determine if a user's profile is activated
is_active = models.BooleanField(default=True)
# `is_staff` determines if a user should have access to django admin
is_staff = models.BooleanField(default=False)
# Specify model manager to be used for the objects
# This is need to work with UserModel in Django CLI so that it knows how to create and control users
objects = UserProfileManager()
# Override `USERNAME_FIELD` to user `email` instead of `username` for authentication
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['name']
def get_full_name(self):
"""Retrieve full name of the user."""
return self.name
def get_short_name(self):
"""Retrieve short name of the user."""
return self.name
def __str__(self):
"""Return string representation of the user."""
return self.email
| 36.257576 | 105 | 0.700376 |
94cd9d564d8d8a3355af8699a25007f149ce3ead | 2,353 | py | Python | signal_transformation/voice/lrtr.py | Ilyushin/signal-transformation | 3e67fd0d8c005243bbe9d325303117b4e3dab505 | [
"MIT"
]
| 1 | 2019-08-12T12:56:51.000Z | 2019-08-12T12:56:51.000Z | signal_transformation/voice/lrtr.py | Ilyushin/signal-transformation | 3e67fd0d8c005243bbe9d325303117b4e3dab505 | [
"MIT"
]
| 5 | 2019-08-12T09:56:02.000Z | 2020-02-28T09:21:49.000Z | signal_transformation/voice/lrtr.py | Ilyushin/signal-transformation | 3e67fd0d8c005243bbe9d325303117b4e3dab505 | [
"MIT"
]
| null | null | null | '''
Transformation of a signal which based on Librosa
'''
import librosa
def wav_to_pcm(wav_file, sample_rate=16000, trimmed=False):
'''
Transform a waf file to PCM
:param wav_file: Path to a wav file
:param sample_rate:
:param trimmed:
:return: PCM
'''
pcm, sr = librosa.core.load(
wav_file,
sr=sample_rate
)
if trimmed:
pcm, _ = librosa.effects.trim(pcm)
return pcm
def pcm_to_stft(
waveform,
n_fft=1024,
hop_length=256,
win_length=1024
):
'''
Transform signal to STFT
:param waveform:
:param n_fft:
:param hop_length:
:param win_length:
:return: STFT
'''
stft = librosa.core.stft(
waveform,
n_fft=n_fft,
hop_length=hop_length,
win_length=win_length
)
return stft
def pcm_to_mel_spec(
waveform,
sample_rate=16000,
n_fft=1024,
hop_length=256,
n_mels=128
):
'''
Transfrom wav to a mel spectrogram
:param waveform:
:param sample_rate:
:param n_fft:
:param hop_length:
:param n_mels:
:return:
'''
mel_spec = librosa.feature.melspectrogram(
waveform,
sr=sample_rate,
n_fft=n_fft,
hop_length=hop_length,
n_mels=n_mels
)
return mel_spec
def pcm_to_mfcc(waveform, sample_rate=16000, hop_length=256, n_mfcc=13):
'''
Compute MFCC features from the pcm
:param sample_rate:
:param waveform:
:param hop_length:
:param n_mfcc:
:return:
'''
return librosa.feature.mfcc(
y=waveform,
sr=sample_rate,
hop_length=hop_length,
n_mfcc=n_mfcc
)
def wav_to_magnitude(
path_wav_file,
sample_rate=16000,
trimmed=False,
n_fft=1024,
hop_length=256,
win_length=1024
):
'''
Extract magnitude from a signal
:param path_wav_file:
:param sample_rate:
:param trimmed:
:param n_fft:
:param hop_length:
:param win_length:
:return: STFT
'''
pcm = wav_to_pcm(path_wav_file, sample_rate=sample_rate, trimmed=trimmed)
stft = pcm_to_stft(
pcm,
n_fft=n_fft,
hop_length=hop_length,
win_length=win_length
)
magnitude, _ = librosa.magphase(stft)
return magnitude
| 18.975806 | 77 | 0.59881 |
ba1277d4b45b04d5d47d1e994a13895ab03329cf | 1,124 | py | Python | app.py | KiwiXR/WhoMovedMyGPU | efd438ea8d5c53d0d23eda7e0f26505d929a9f0b | [
"MIT"
]
| 1 | 2021-11-15T14:20:05.000Z | 2021-11-15T14:20:05.000Z | app.py | KiwiXR/WhoMovedMyGPU | efd438ea8d5c53d0d23eda7e0f26505d929a9f0b | [
"MIT"
]
| null | null | null | app.py | KiwiXR/WhoMovedMyGPU | efd438ea8d5c53d0d23eda7e0f26505d929a9f0b | [
"MIT"
]
| null | null | null | import threading
from flask import Flask, render_template
import ssh
from gevent import pywsgi
app = Flask(__name__)
host_info = {}
cfg_dict = {}
@app.before_first_request
def start_ssh():
global cfg_dict, host_info
ssh_pool, cfg_dict = ssh.init()
for (ssh_id, (host, ssh_cfg)) in enumerate(ssh_pool.items()):
t = threading.Thread(target=ssh.query_host, args=(ssh_id, host, ssh_cfg, host_info, cfg_dict['timeout']))
t.start()
@app.route('/')
def hello_world():
return "hello world"
@app.route('/gpu', methods=['GET', 'POST'])
def gpu():
global host_info, cfg_dict
host_i = dict(sorted(host_info.items(), key=lambda item: item[0]))
if cfg_dict['warmup'] > 0:
refresh = 5
cfg_dict['warmup'] -= 1
else:
refresh = cfg_dict['refresh']
return render_template('gpu.html', title='Who Moved My GPU?', host_info=host_i, refresh_time=refresh)
@app.route('/fix', methods=['GET', 'POST'])
def fix():
return render_template('fix.html')
if __name__ == '__main__':
server = pywsgi.WSGIServer(('0.0.0.0', 1301), app)
server.serve_forever()
| 23.914894 | 113 | 0.658363 |
6bbf08cea0b4b30c730af8e4338936ae7bbc046d | 695 | py | Python | baselines/DMCNN_BiLSTM_(CRF)/model/layers/embedding.py | fliingelephant/MAVEN-dataset | 72a431cc579b13958ec93dfe21a7c5f89133ae47 | [
"MIT"
]
| 91 | 2020-10-06T06:51:52.000Z | 2022-03-26T11:05:24.000Z | baselines/DMCNN_BiLSTM_(CRF)/model/layers/embedding.py | xianhuaxizi/MAVEN-dataset | a80f6ece6552261edf7bf28a0befa655e5b8fb1d | [
"MIT"
]
| 13 | 2020-10-24T02:08:40.000Z | 2022-02-17T15:13:34.000Z | baselines/DMCNN_BiLSTM_(CRF)/model/layers/embedding.py | xianhuaxizi/MAVEN-dataset | a80f6ece6552261edf7bf28a0befa655e5b8fb1d | [
"MIT"
]
| 27 | 2020-12-20T20:48:14.000Z | 2022-03-07T02:37:53.000Z | import torch
import torch.nn as nn
import numpy as np
from utils.global_variables import Global
class Embedding(nn.Module):
def __init__(self, config):
super(Embedding, self).__init__()
if Global.word2vec_mat is None:
weight = None
self.vocab_size = config.getint("runtime", "vocab_size")
self.embedding_size = config.getint("runtime", "embedding_size")
else:
weight = torch.from_numpy(Global.word2vec_mat).float()
self.vocab_size, self.embedding_size = weight.size()
self.embedding = nn.Embedding.from_pretrained(weight)
def forward(self, input):
return self.embedding(input)
| 34.75 | 76 | 0.657554 |
a1ffe5fda893d931bb50fe6de7e7b3c8677f2d86 | 2,916 | py | Python | manimlib/mobject/shape_matchers.py | sunkisser/manim | 39673a80d7bbbea258c35ce5a1d37a0911aae4f1 | [
"MIT"
]
| 1 | 2022-03-23T06:27:22.000Z | 2022-03-23T06:27:22.000Z | manimlib/mobject/shape_matchers.py | sunkisser/manim | 39673a80d7bbbea258c35ce5a1d37a0911aae4f1 | [
"MIT"
]
| null | null | null | manimlib/mobject/shape_matchers.py | sunkisser/manim | 39673a80d7bbbea258c35ce5a1d37a0911aae4f1 | [
"MIT"
]
| null | null | null | from __future__ import annotations
from manimlib.constants import *
from manimlib.mobject.geometry import Line
from manimlib.mobject.geometry import Rectangle
from manimlib.mobject.types.vectorized_mobject import VGroup
from manimlib.mobject.types.vectorized_mobject import VMobject
from manimlib.utils.color import Color
from manimlib.utils.customization import get_customization
from manimlib.utils.config_ops import digest_config
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from typing import Union, Sequence
from manimlib.mobject.mobject import Mobject
ManimColor = Union[str, Color, Sequence[float]]
class SurroundingRectangle(Rectangle):
CONFIG = {
"color": YELLOW,
"buff": SMALL_BUFF,
}
def __init__(self, mobject: Mobject, **kwargs):
digest_config(self, kwargs)
kwargs["width"] = mobject.get_width() + 2 * self.buff
kwargs["height"] = mobject.get_height() + 2 * self.buff
Rectangle.__init__(self, **kwargs)
self.move_to(mobject)
class BackgroundRectangle(SurroundingRectangle):
CONFIG = {
"stroke_width": 0,
"stroke_opacity": 0,
"fill_opacity": 0.75,
"buff": 0
}
def __init__(self, mobject: Mobject, color: ManimColor = None, **kwargs):
if color is None:
color = get_customization()['style']['background_color']
SurroundingRectangle.__init__(self, mobject, color=color, **kwargs)
self.original_fill_opacity = self.fill_opacity
def pointwise_become_partial(self, mobject: Mobject, a: float, b: float):
self.set_fill(opacity=b * self.original_fill_opacity)
return self
def set_style_data(
self,
stroke_color: ManimColor | None = None,
stroke_width: float | None = None,
fill_color: ManimColor | None = None,
fill_opacity: float | None = None,
family: bool = True
):
# Unchangeable style, except for fill_opacity
VMobject.set_style_data(
self,
stroke_color=BLACK,
stroke_width=0,
fill_color=BLACK,
fill_opacity=fill_opacity
)
return self
def get_fill_color(self) -> Color:
return Color(self.color)
class Cross(VGroup):
CONFIG = {
"stroke_color": RED,
"stroke_width": [0, 6, 0],
}
def __init__(self, mobject: Mobject, **kwargs):
super().__init__(
Line(UL, DR),
Line(UR, DL),
)
self.insert_n_curves(2)
self.replace(mobject, stretch=True)
self.set_stroke(self.stroke_color, width=self.stroke_width)
class Underline(Line):
CONFIG = {
"buff": SMALL_BUFF,
}
def __init__(self, mobject: Mobject, **kwargs):
super().__init__(LEFT, RIGHT, **kwargs)
self.match_width(mobject)
self.next_to(mobject, DOWN, buff=self.buff)
| 29.454545 | 77 | 0.648148 |
861ff46a450f9bcb522c72a98b2d404d6010ab89 | 16,079 | py | Python | log_mito/model_683.py | LoLab-VU/Bayesian_Inference_of_Network_Dynamics | 54a5ef7e868be34289836bbbb024a2963c0c9c86 | [
"MIT"
]
| null | null | null | log_mito/model_683.py | LoLab-VU/Bayesian_Inference_of_Network_Dynamics | 54a5ef7e868be34289836bbbb024a2963c0c9c86 | [
"MIT"
]
| null | null | null | log_mito/model_683.py | LoLab-VU/Bayesian_Inference_of_Network_Dynamics | 54a5ef7e868be34289836bbbb024a2963c0c9c86 | [
"MIT"
]
| null | null | null | # exported from PySB model 'model'
from pysb import Model, Monomer, Parameter, Expression, Compartment, Rule, Observable, Initial, MatchOnce, Annotation, ANY, WILD
Model()
Monomer('Ligand', ['Receptor'])
Monomer('ParpU', ['C3A'])
Monomer('C8A', ['BidU'])
Monomer('SmacM', ['BaxA'])
Monomer('BaxM', ['BidM', 'BaxA'])
Monomer('Apop', ['C3pro', 'Xiap'])
Monomer('Fadd', ['Receptor', 'C8pro'])
Monomer('SmacC', ['Xiap'])
Monomer('ParpC')
Monomer('Xiap', ['SmacC', 'Apop', 'C3A'])
Monomer('C9')
Monomer('C3ub')
Monomer('C8pro', ['Fadd'])
Monomer('C3pro', ['Apop'])
Monomer('CytoCM', ['BaxA'])
Monomer('CytoCC')
Monomer('BaxA', ['BaxM', 'BaxA_1', 'BaxA_2', 'SmacM', 'CytoCM'])
Monomer('ApafI')
Monomer('BidU', ['C8A'])
Monomer('BidT')
Monomer('C3A', ['Xiap', 'ParpU'])
Monomer('ApafA')
Monomer('BidM', ['BaxM'])
Monomer('Receptor', ['Ligand', 'Fadd'])
Parameter('bind_0_Ligand_binder_Receptor_binder_target_2kf', 1.0)
Parameter('bind_0_Ligand_binder_Receptor_binder_target_1kr', 1.0)
Parameter('bind_0_Receptor_binder_Fadd_binder_target_2kf', 1.0)
Parameter('bind_0_Receptor_binder_Fadd_binder_target_1kr', 1.0)
Parameter('substrate_binding_0_Fadd_catalyzer_C8pro_substrate_2kf', 1.0)
Parameter('substrate_binding_0_Fadd_catalyzer_C8pro_substrate_1kr', 1.0)
Parameter('catalytic_step_0_Fadd_catalyzer_C8pro_substrate_C8A_product_1kc', 1.0)
Parameter('catalysis_0_C8A_catalyzer_BidU_substrate_BidT_product_2kf', 1.0)
Parameter('catalysis_0_C8A_catalyzer_BidU_substrate_BidT_product_1kr', 1.0)
Parameter('catalysis_1_C8A_catalyzer_BidU_substrate_BidT_product_1kc', 1.0)
Parameter('conversion_0_CytoCC_subunit_d_ApafI_subunit_c_ApafA_complex_2kf', 1.0)
Parameter('conversion_0_CytoCC_subunit_d_ApafI_subunit_c_ApafA_complex_1kr', 1.0)
Parameter('inhibition_0_SmacC_inhibitor_Xiap_inh_target_2kf', 1.0)
Parameter('inhibition_0_SmacC_inhibitor_Xiap_inh_target_1kr', 1.0)
Parameter('conversion_0_C9_subunit_d_ApafA_subunit_c_Apop_complex_2kf', 1.0)
Parameter('conversion_0_C9_subunit_d_ApafA_subunit_c_Apop_complex_1kr', 1.0)
Parameter('catalysis_0_Apop_catalyzer_C3pro_substrate_C3A_product_2kf', 1.0)
Parameter('catalysis_0_Apop_catalyzer_C3pro_substrate_C3A_product_1kr', 1.0)
Parameter('catalysis_1_Apop_catalyzer_C3pro_substrate_C3A_product_1kc', 1.0)
Parameter('inhibition_0_Xiap_inhibitor_Apop_inh_target_2kf', 1.0)
Parameter('inhibition_0_Xiap_inhibitor_Apop_inh_target_1kr', 1.0)
Parameter('catalysis_0_Xiap_catalyzer_C3A_substrate_C3ub_product_2kf', 1.0)
Parameter('catalysis_0_Xiap_catalyzer_C3A_substrate_C3ub_product_1kr', 1.0)
Parameter('catalysis_1_Xiap_catalyzer_C3A_substrate_C3ub_product_1kc', 1.0)
Parameter('catalysis_0_C3A_catalyzer_ParpU_substrate_ParpC_product_2kf', 1.0)
Parameter('catalysis_0_C3A_catalyzer_ParpU_substrate_ParpC_product_1kr', 1.0)
Parameter('catalysis_1_C3A_catalyzer_ParpU_substrate_ParpC_product_1kc', 1.0)
Parameter('equilibration_0_BidT_equil_a_BidM_equil_b_1kf', 1.0)
Parameter('equilibration_0_BidT_equil_a_BidM_equil_b_1kr', 1.0)
Parameter('catalysis_0_BidM_catalyzer_BaxM_substrate_BaxA_product_2kf', 1.0)
Parameter('catalysis_0_BidM_catalyzer_BaxM_substrate_BaxA_product_1kr', 1.0)
Parameter('catalysis_1_BidM_catalyzer_BaxM_substrate_BaxA_product_1kc', 1.0)
Parameter('self_catalyze_0_BaxA_self_catalyzer_BaxM_self_substrate_2kf', 1.0)
Parameter('self_catalyze_0_BaxA_self_catalyzer_BaxM_self_substrate_1kr', 1.0)
Parameter('self_catalyze_1_BaxA_self_catalyzer_BaxM_self_substrate_1kc', 1.0)
Parameter('pore_formation_0_BaxA_pore_2kf', 1.0)
Parameter('pore_formation_0_BaxA_pore_1kr', 1.0)
Parameter('pore_formation_1_BaxA_pore_2kf', 1.0)
Parameter('pore_formation_1_BaxA_pore_1kr', 1.0)
Parameter('pore_formation_2_BaxA_pore_2kf', 1.0)
Parameter('pore_formation_2_BaxA_pore_1kr', 1.0)
Parameter('transport_0_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C_2kf', 1.0)
Parameter('transport_0_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C_1kr', 1.0)
Parameter('transport_1_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C_1kc', 1.0)
Parameter('transport_0_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C_2kf', 1.0)
Parameter('transport_0_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C_1kr', 1.0)
Parameter('transport_1_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C_1kc', 1.0)
Parameter('Ligand_0', 1000.0)
Parameter('ParpU_0', 1000000.0)
Parameter('C8A_0', 0.0)
Parameter('SmacM_0', 100000.0)
Parameter('BaxM_0', 40000.0)
Parameter('Apop_0', 0.0)
Parameter('Fadd_0', 130000.0)
Parameter('SmacC_0', 0.0)
Parameter('ParpC_0', 0.0)
Parameter('Xiap_0', 170750.0)
Parameter('C9_0', 100000.0)
Parameter('C3ub_0', 0.0)
Parameter('C8pro_0', 130000.0)
Parameter('C3pro_0', 21000.0)
Parameter('CytoCM_0', 500000.0)
Parameter('CytoCC_0', 0.0)
Parameter('BaxA_0', 0.0)
Parameter('ApafI_0', 100000.0)
Parameter('BidU_0', 171000.0)
Parameter('BidT_0', 0.0)
Parameter('C3A_0', 0.0)
Parameter('ApafA_0', 0.0)
Parameter('BidM_0', 0.0)
Parameter('Receptor_0', 100.0)
Observable('Ligand_obs', Ligand())
Observable('ParpU_obs', ParpU())
Observable('C8A_obs', C8A())
Observable('SmacM_obs', SmacM())
Observable('BaxM_obs', BaxM())
Observable('Apop_obs', Apop())
Observable('Fadd_obs', Fadd())
Observable('SmacC_obs', SmacC())
Observable('ParpC_obs', ParpC())
Observable('Xiap_obs', Xiap())
Observable('C9_obs', C9())
Observable('C3ub_obs', C3ub())
Observable('C8pro_obs', C8pro())
Observable('C3pro_obs', C3pro())
Observable('CytoCM_obs', CytoCM())
Observable('CytoCC_obs', CytoCC())
Observable('BaxA_obs', BaxA())
Observable('ApafI_obs', ApafI())
Observable('BidU_obs', BidU())
Observable('BidT_obs', BidT())
Observable('C3A_obs', C3A())
Observable('ApafA_obs', ApafA())
Observable('BidM_obs', BidM())
Observable('Receptor_obs', Receptor())
Rule('bind_0_Ligand_binder_Receptor_binder_target', Ligand(Receptor=None) + Receptor(Ligand=None, Fadd=None) | Ligand(Receptor=1) % Receptor(Ligand=1, Fadd=None), bind_0_Ligand_binder_Receptor_binder_target_2kf, bind_0_Ligand_binder_Receptor_binder_target_1kr)
Rule('bind_0_Receptor_binder_Fadd_binder_target', Receptor(Ligand=ANY, Fadd=None) + Fadd(Receptor=None, C8pro=None) | Receptor(Ligand=ANY, Fadd=1) % Fadd(Receptor=1, C8pro=None), bind_0_Receptor_binder_Fadd_binder_target_2kf, bind_0_Receptor_binder_Fadd_binder_target_1kr)
Rule('substrate_binding_0_Fadd_catalyzer_C8pro_substrate', Fadd(Receptor=ANY, C8pro=None) + C8pro(Fadd=None) | Fadd(Receptor=ANY, C8pro=1) % C8pro(Fadd=1), substrate_binding_0_Fadd_catalyzer_C8pro_substrate_2kf, substrate_binding_0_Fadd_catalyzer_C8pro_substrate_1kr)
Rule('catalytic_step_0_Fadd_catalyzer_C8pro_substrate_C8A_product', Fadd(Receptor=ANY, C8pro=1) % C8pro(Fadd=1) >> Fadd(Receptor=ANY, C8pro=None) + C8A(BidU=None), catalytic_step_0_Fadd_catalyzer_C8pro_substrate_C8A_product_1kc)
Rule('catalysis_0_C8A_catalyzer_BidU_substrate_BidT_product', C8A(BidU=None) + BidU(C8A=None) | C8A(BidU=1) % BidU(C8A=1), catalysis_0_C8A_catalyzer_BidU_substrate_BidT_product_2kf, catalysis_0_C8A_catalyzer_BidU_substrate_BidT_product_1kr)
Rule('catalysis_1_C8A_catalyzer_BidU_substrate_BidT_product', C8A(BidU=1) % BidU(C8A=1) >> C8A(BidU=None) + BidT(), catalysis_1_C8A_catalyzer_BidU_substrate_BidT_product_1kc)
Rule('conversion_0_CytoCC_subunit_d_ApafI_subunit_c_ApafA_complex', ApafI() + CytoCC() | ApafA(), conversion_0_CytoCC_subunit_d_ApafI_subunit_c_ApafA_complex_2kf, conversion_0_CytoCC_subunit_d_ApafI_subunit_c_ApafA_complex_1kr)
Rule('inhibition_0_SmacC_inhibitor_Xiap_inh_target', SmacC(Xiap=None) + Xiap(SmacC=None, Apop=None, C3A=None) | SmacC(Xiap=1) % Xiap(SmacC=1, Apop=None, C3A=None), inhibition_0_SmacC_inhibitor_Xiap_inh_target_2kf, inhibition_0_SmacC_inhibitor_Xiap_inh_target_1kr)
Rule('conversion_0_C9_subunit_d_ApafA_subunit_c_Apop_complex', ApafA() + C9() | Apop(C3pro=None, Xiap=None), conversion_0_C9_subunit_d_ApafA_subunit_c_Apop_complex_2kf, conversion_0_C9_subunit_d_ApafA_subunit_c_Apop_complex_1kr)
Rule('catalysis_0_Apop_catalyzer_C3pro_substrate_C3A_product', Apop(C3pro=None, Xiap=None) + C3pro(Apop=None) | Apop(C3pro=1, Xiap=None) % C3pro(Apop=1), catalysis_0_Apop_catalyzer_C3pro_substrate_C3A_product_2kf, catalysis_0_Apop_catalyzer_C3pro_substrate_C3A_product_1kr)
Rule('catalysis_1_Apop_catalyzer_C3pro_substrate_C3A_product', Apop(C3pro=1, Xiap=None) % C3pro(Apop=1) >> Apop(C3pro=None, Xiap=None) + C3A(Xiap=None, ParpU=None), catalysis_1_Apop_catalyzer_C3pro_substrate_C3A_product_1kc)
Rule('inhibition_0_Xiap_inhibitor_Apop_inh_target', Xiap(SmacC=None, Apop=None, C3A=None) + Apop(C3pro=None, Xiap=None) | Xiap(SmacC=None, Apop=1, C3A=None) % Apop(C3pro=None, Xiap=1), inhibition_0_Xiap_inhibitor_Apop_inh_target_2kf, inhibition_0_Xiap_inhibitor_Apop_inh_target_1kr)
Rule('catalysis_0_Xiap_catalyzer_C3A_substrate_C3ub_product', Xiap(SmacC=None, Apop=None, C3A=None) + C3A(Xiap=None, ParpU=None) | Xiap(SmacC=None, Apop=None, C3A=1) % C3A(Xiap=1, ParpU=None), catalysis_0_Xiap_catalyzer_C3A_substrate_C3ub_product_2kf, catalysis_0_Xiap_catalyzer_C3A_substrate_C3ub_product_1kr)
Rule('catalysis_1_Xiap_catalyzer_C3A_substrate_C3ub_product', Xiap(SmacC=None, Apop=None, C3A=1) % C3A(Xiap=1, ParpU=None) >> Xiap(SmacC=None, Apop=None, C3A=None) + C3ub(), catalysis_1_Xiap_catalyzer_C3A_substrate_C3ub_product_1kc)
Rule('catalysis_0_C3A_catalyzer_ParpU_substrate_ParpC_product', C3A(Xiap=None, ParpU=None) + ParpU(C3A=None) | C3A(Xiap=None, ParpU=1) % ParpU(C3A=1), catalysis_0_C3A_catalyzer_ParpU_substrate_ParpC_product_2kf, catalysis_0_C3A_catalyzer_ParpU_substrate_ParpC_product_1kr)
Rule('catalysis_1_C3A_catalyzer_ParpU_substrate_ParpC_product', C3A(Xiap=None, ParpU=1) % ParpU(C3A=1) >> C3A(Xiap=None, ParpU=None) + ParpC(), catalysis_1_C3A_catalyzer_ParpU_substrate_ParpC_product_1kc)
Rule('equilibration_0_BidT_equil_a_BidM_equil_b', BidT() | BidM(BaxM=None), equilibration_0_BidT_equil_a_BidM_equil_b_1kf, equilibration_0_BidT_equil_a_BidM_equil_b_1kr)
Rule('catalysis_0_BidM_catalyzer_BaxM_substrate_BaxA_product', BidM(BaxM=None) + BaxM(BidM=None, BaxA=None) | BidM(BaxM=1) % BaxM(BidM=1, BaxA=None), catalysis_0_BidM_catalyzer_BaxM_substrate_BaxA_product_2kf, catalysis_0_BidM_catalyzer_BaxM_substrate_BaxA_product_1kr)
Rule('catalysis_1_BidM_catalyzer_BaxM_substrate_BaxA_product', BidM(BaxM=1) % BaxM(BidM=1, BaxA=None) >> BidM(BaxM=None) + BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None), catalysis_1_BidM_catalyzer_BaxM_substrate_BaxA_product_1kc)
Rule('self_catalyze_0_BaxA_self_catalyzer_BaxM_self_substrate', BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) + BaxM(BidM=None, BaxA=None) | BaxA(BaxM=1, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) % BaxM(BidM=None, BaxA=1), self_catalyze_0_BaxA_self_catalyzer_BaxM_self_substrate_2kf, self_catalyze_0_BaxA_self_catalyzer_BaxM_self_substrate_1kr)
Rule('self_catalyze_1_BaxA_self_catalyzer_BaxM_self_substrate', BaxA(BaxM=1, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) % BaxM(BidM=None, BaxA=1) >> BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) + BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None), self_catalyze_1_BaxA_self_catalyzer_BaxM_self_substrate_1kc)
Rule('pore_formation_0_BaxA_pore', BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) + BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) | BaxA(BaxM=None, BaxA_1=None, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=None, SmacM=None, CytoCM=None), pore_formation_0_BaxA_pore_2kf, pore_formation_0_BaxA_pore_1kr)
Rule('pore_formation_1_BaxA_pore', BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) + BaxA(BaxM=None, BaxA_1=None, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=None, SmacM=None, CytoCM=None) | BaxA(BaxM=None, BaxA_1=3, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None), pore_formation_1_BaxA_pore_2kf, pore_formation_1_BaxA_pore_1kr)
Rule('pore_formation_2_BaxA_pore', BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None) + BaxA(BaxM=None, BaxA_1=3, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) | BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=None, CytoCM=None), pore_formation_2_BaxA_pore_2kf, pore_formation_2_BaxA_pore_1kr)
Rule('transport_0_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C', BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=None, CytoCM=None) + SmacM(BaxA=None) | BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=5, CytoCM=None) % SmacM(BaxA=5), transport_0_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C_2kf, transport_0_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C_1kr)
Rule('transport_1_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C', BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=5, CytoCM=None) % SmacM(BaxA=5) >> BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=None, CytoCM=None) + SmacC(Xiap=None), transport_1_BaxA_pore_SmacM_cargo_M_SmacC_cargo_C_1kc)
Rule('transport_0_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C', BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=None, CytoCM=None) + CytoCM(BaxA=None) | BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=None, CytoCM=5) % CytoCM(BaxA=5), transport_0_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C_2kf, transport_0_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C_1kr)
Rule('transport_1_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C', BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=None, CytoCM=5) % CytoCM(BaxA=5) >> BaxA(BaxM=None, BaxA_1=4, BaxA_2=1, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=1, BaxA_2=2, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=2, BaxA_2=3, SmacM=None, CytoCM=None) % BaxA(BaxM=None, BaxA_1=3, BaxA_2=4, SmacM=None, CytoCM=None) + CytoCC(), transport_1_BaxA_pore_CytoCM_cargo_M_CytoCC_cargo_C_1kc)
Initial(Ligand(Receptor=None), Ligand_0)
Initial(ParpU(C3A=None), ParpU_0)
Initial(C8A(BidU=None), C8A_0)
Initial(SmacM(BaxA=None), SmacM_0)
Initial(BaxM(BidM=None, BaxA=None), BaxM_0)
Initial(Apop(C3pro=None, Xiap=None), Apop_0)
Initial(Fadd(Receptor=None, C8pro=None), Fadd_0)
Initial(SmacC(Xiap=None), SmacC_0)
Initial(ParpC(), ParpC_0)
Initial(Xiap(SmacC=None, Apop=None, C3A=None), Xiap_0)
Initial(C9(), C9_0)
Initial(C3ub(), C3ub_0)
Initial(C8pro(Fadd=None), C8pro_0)
Initial(C3pro(Apop=None), C3pro_0)
Initial(CytoCM(BaxA=None), CytoCM_0)
Initial(CytoCC(), CytoCC_0)
Initial(BaxA(BaxM=None, BaxA_1=None, BaxA_2=None, SmacM=None, CytoCM=None), BaxA_0)
Initial(ApafI(), ApafI_0)
Initial(BidU(C8A=None), BidU_0)
Initial(BidT(), BidT_0)
Initial(C3A(Xiap=None, ParpU=None), C3A_0)
Initial(ApafA(), ApafA_0)
Initial(BidM(BaxM=None), BidM_0)
Initial(Receptor(Ligand=None, Fadd=None), Receptor_0)
| 87.863388 | 710 | 0.80347 |
91fc6bbf1c855d13b11b4ea9033a2fc5cce6f17d | 12,167 | py | Python | src/poliastro/earth/atmosphere/coesa62.py | tomaszmrugalski/poliastro | 463cade72eb26e4db09ef613fc5d7cc972581617 | [
"MIT"
]
| null | null | null | src/poliastro/earth/atmosphere/coesa62.py | tomaszmrugalski/poliastro | 463cade72eb26e4db09ef613fc5d7cc972581617 | [
"MIT"
]
| 1 | 2020-10-05T08:24:31.000Z | 2020-10-05T08:24:31.000Z | src/poliastro/earth/atmosphere/coesa62.py | tomaszmrugalski/poliastro | 463cade72eb26e4db09ef613fc5d7cc972581617 | [
"MIT"
]
| null | null | null | """ The U.S. Standard Atmosphere 1966 depicts idealized middle-latitude
year-round mean conditions for the range of solar activity that occurs between
sunspot minimum and sunspot maximum.
+--------+---------+---------+-----------+---------------+---------------+
| Z (km) | H (km) | T (K) | p (mbar) | rho (kg / m3) | beta (K / km) |
+--------+---------+---------+-----------+---------------+---------------+
| 0.0 | 0.0 | 288.150 | 1.01325e3 | 1.2250 | -6.5 |
+--------+---------+---------+-----------+---------------+---------------+
| 11.019 | 11.0 | 216.650 | 2.2632e2 | 3.6392e-1 | 0.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 20.063 | 20.0 | 216.650 | 5.4749e1 | 8.8035e-2 | 1.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 32.162 | 32.0 | 228.650 | 8.68014 | 1.3225e-2 | 2.8 |
+--------+---------+---------+-----------+---------------+---------------+
| 47.350 | 47.0 | 270.650 | 1.109050 | 1.4275e-3 | 0.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 51.413 | 52.0 | 270.650 | 5.90005e-1| 7.5943e-4 | -2.8 |
+--------+---------+---------+-----------+---------------+---------------+
| 61.591 | 61.0 | 252.650 | 1.82099e-1| 2.5109e-4 | -2.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 79.994 | 79.0 | 180.650 | 1.0377e-2 | 2.001e-5 | 0.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 90.0 | 88.743 | 180.650 | 1.6438e-3 | 3.170e-6 | 0.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 100.0 | 98.451 | 210.020 | 3.0075e-4 | 4.974e-7 | 5.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 110.0 | 108.129 | 257.000 | 7.3544e-5 | 9.829e-8 | 10.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 120.0 | 117.776 | 349.490 | 2.5217e-5 | 2.436e-8 | 20.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 150.0 | 146.541 | 892.790 | 5.0617e-6 | 1.836e-9 | 15.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 160.0 | 156.071 | 1022.23 | 3.6943e-6 | 1.159e-9 | 10.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 170.0 | 165.571 | 1105.51 | 2.7926e-6 | 8.036e-10 | 7.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 190.0 | 184.485 | 1205.50 | 1.6852e-6 | 4.347e-10 | 5.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 230.0 | 221.967 | 1321.70 | 6.9604e-7 | 1.564e-10 | 4.0 |
+--------+---------+---------+-----------+---------------+---------------+
| 300.0 | 286.476 | 1432.11 | 1.8838e-7 | 3.585e-11 | 3.3 |
+--------+---------+---------+-----------+---------------+---------------+
| 400.0 | 376.312 | 1487.38 | 4.0304e-8 | 6.498e-12 | 2.6 |
+--------+---------+---------+-----------+---------------+---------------+
| 500.0 | 463.526 | 1499.22 | 1.0957e-8 | 1.577e-12 | 1.7 |
+--------+---------+---------+-----------+---------------+---------------+
| 600.0 | 548.230 | 1506.13 | 3.4502e-9 | 4.640e-13 | 1.1 |
+--------+---------+---------+-----------+---------------+---------------+
| 700.0 | 630.530 | 1507.61 | 1.1918e-9 | 1.537e-13 | 0.0 |
+--------+---------+---------+-----------+---------------+---------------+
"""
import numpy as np
from astropy import units as u
from astropy.io import ascii
from astropy.units import imperial
from astropy.utils.data import get_pkg_data_filename
from scipy.integrate import quad
from poliastro.earth.atmosphere.base import COESA
# Constants come from the original paper to achieve pure implementation
r0 = 6356.766 * u.km
p0 = 1.013250e5 * u.Pa
rho0 = 1.2250 * u.K
T0 = 288.15 * u.K
g0 = 9.80665 * u.m / u.s ** 2
S = 110.4 * u.K
Ti = 273.15 * u.K
beta = 1.458e-6 * u.kg / u.s / u.m / u.K ** (0.5)
_gamma = 1.4
sigma = 3.65e-10 * u.m
N = 6.02257e26 * (u.kg * u.mol) ** -1
R = 8314.32 * u.J / u.kmol / u.K
R_air = 287.053 * u.J / u.kg / u.K
alpha = 34.1632 * u.K / u.km
# Reading layer parameters file
coesa_file = get_pkg_data_filename("data/coesa62.dat")
coesa62_data = ascii.read(coesa_file)
b_levels = coesa62_data["b"].data
zb_levels = coesa62_data["Zb [km]"].data * u.km
hb_levels = coesa62_data["Hb [km]"].data * u.km
Tb_levels = coesa62_data["Tb [K]"].data * u.K
Lb_levels = coesa62_data["Lb [K/km]"].data * u.K / u.km
pb_levels = coesa62_data["pb [mbar]"].data * u.mbar
class COESA62(COESA):
""" Holds the model for U.S Standard Atmosphere 1962. """
def __init__(self):
""" Constructor for the class. """
super().__init__(
b_levels, zb_levels, hb_levels, Tb_levels, Lb_levels, pb_levels
)
def temperature(self, alt, geometric=True):
"""Solves for temperature at given altitude.
Parameters
----------
alt: ~astropy.units.Quantity
Geometric/Geopotential altitude.
geometric: boolean
If `True`, assumes geometric altitude kind.
Returns
-------
T: ~astropy.units.Quantity
Kinetic temeperature.
"""
# Test if altitude is inside valid range
z, h = self._check_altitude(alt, r0, geometric=geometric)
# Get base parameters
i = self._get_index(z, self.zb_levels)
zb = self.zb_levels[i]
Tb = self.Tb_levels[i]
Lb = self.Lb_levels[i]
hb = self.hb_levels[i]
# Apply different equations
if z <= 90 * u.km:
T = Tb + Lb * (h - hb)
else:
T = Tb + Lb * (z - zb)
return T.to(u.K)
def pressure(self, alt, geometric=True):
"""Solves pressure at given altitude.
Parameters
----------
alt: ~astropy.units.Quantity
Geometric/Geopotential altitude.
geometric: boolean
If `True`, assumes geometric altitude.
Returns
-------
p: ~astropy.units.Quantity
Pressure at given altitude.
"""
# Check if valid range and convert to geopotential
z, h = self._check_altitude(alt, r0, geometric=geometric)
# Get base parameters
i = self._get_index(z, self.zb_levels)
zb = self.zb_levels[i]
hb = self.hb_levels[i]
Tb = self.Tb_levels[i]
Lb = self.Lb_levels[i]
pb = self.pb_levels[i]
# if z <= 90km then apply eqn 1.2.10-(3)
if z <= 90 * u.km:
# If Lb is zero then apply eqn 1.2.10-(4)
if Lb == 0.0:
p = pb * np.exp(-g0 * (h - hb) / Tb / R_air)
else:
T = self.temperature(z)
p = pb * (T / Tb) ** (-g0 / R_air / Lb)
# if 90 < Z < 700 km then eqn 1.2.10-(5) is applied
else:
# Converting all the units into SI unit and taking their magnitude
Lb_v = Lb.to(u.K / u.m).value
r0_v = r0.to(u.m).value
z_v = z.to(u.m).value
zb_v = zb.to(u.m).value
Tb_v = Tb.value
g0_v = g0.value
R_air_v = R_air.value
# Putting g = (g0*(r0/(r0 +z))**2) in (g * dz / z - zb + Tb/Lb)
# and integrating it.
integrand = quad(
lambda x: (g0_v * (r0_v / (r0_v + x)) ** 2) / (x - zb_v + Tb_v / Lb_v),
zb_v,
z_v,
)
pb = pb.to(u.Pa)
p = (pb * np.exp((-1 / R_air_v / Lb_v) * integrand[0])).to(u.mbar)
return p
def density(self, alt, geometric=True):
"""Solves density at given altitude.
Parameters
----------
alt: ~astropy.units.Quantity
Geometric/Geopotential altitude.
geometric: boolean
If `True`, assumes geometric altitude.
Returns
-------
rho: ~astropy.units.Quantity
Density at given altitude.
"""
# Check if valid range and convert to geopotential
z, h = self._check_altitude(alt, r0, geometric=geometric)
# Solve temperature and pressure
T = self.temperature(z)
p = self.pressure(z)
rho = p / R_air / T
return rho.to(u.kg / u.m ** 3)
def properties(self, alt, geometric=True):
"""Solves density at given height.
Parameters
----------
alt: ~astropy.units.Quantity
Geometric/Geopotential height.
geometric: boolean
If `True`, assumes that `alt` argument is geometric kind.
Returns
-------
T: ~astropy.units.Quantity
Temperature at given height.
p: ~astropy.units.Quantity
Pressure at given height.
rho: ~astropy.units.Quantity
Density at given height.
"""
T = self.temperature(alt, geometric=geometric)
p = self.pressure(alt, geometric=geometric)
rho = self.density(alt, geometric=geometric)
return T, p, rho
def sound_speed(self, alt, geometric=True):
"""Solves speed of sound at given height.
Parameters
----------
alt: ~astropy.units.Quantity
Geometric/Geopotential height.
geometric: boolean
If `True`, assumes that `alt` argument is geometric kind.
Returns
-------
Cs: ~astropy.units.Quantity
Speed of Sound at given height.
"""
# Check if valid range and convert to geopotential
z, h = self._check_altitude(alt, r0, geometric=geometric)
if z > 90 * u.km:
raise ValueError(
"Speed of sound in COESA62 has just been implemented up to 90km."
)
T = self.temperature(alt, geometric).value
# using eqn-1.3.7-(1)
Cs = ((_gamma * R_air.value * T) ** 0.5) * (u.m / u.s)
return Cs
def viscosity(self, alt, geometric=True):
"""Solves dynamic viscosity at given height.
Parameters
----------
alt: ~astropy.units.Quantity
Geometric/Geopotential height.
geometric: boolean
If `True`, assumes that `alt` argument is geometric kind.
Returns
-------
mu: ~astropy.units.Quantity
Dynamic viscosity at given height.
"""
# Check if valid range and convert to geopotential
z, h = self._check_altitude(alt, r0, geometric=geometric)
if z > 90 * u.km:
raise ValueError(
"Dynamic Viscosity in COESA62 has just been implemented up to 90km."
)
T = self.temperature(alt, geometric).value
# using eqn-1.3.8-(1)
mu = (beta.value * T ** 1.5 / (T + S.value)) * (u.kg / u.m / u.s)
return mu
def thermal_conductivity(self, alt, geometric=True):
"""Solves coefficient of thermal conductivity at given height.
Parameters
----------
alt: ~astropy.units.Quantity
Geometric/Geopotential height.
geometric: boolean
If `True`, assumes that `alt` argument is geometric kind.
Returns
-------
k: ~astropy.units.Quantity
coefficient of thermal conductivity at given height.
"""
# Check if valid range and convert to geopotential
z, h = self._check_altitude(alt, r0, geometric=geometric)
if z > 90 * u.km:
raise ValueError(
"Thermal conductivity in COESA62 has just been implemented up to 90km."
)
T = self.temperature(alt, geometric=geometric).value
# using eqn-1.3.10-(1)
k = (6.325e-7 * T ** 1.5 / (T + 245.4 * (10 ** (-12.0 / T)))) * (
imperial.kcal / u.m / u.s / u.K
)
return k
| 36.758308 | 87 | 0.449577 |
79587dec57730be24ebf60f67a20c57c2b0d57f5 | 1,716 | py | Python | tests/test_cryptocurrencychart.py | gdoermann/cryptocurrencychart | 713dae89304c86599f4a14a6dbd40f2e21c77048 | [
"MIT"
]
| 1 | 2021-04-16T19:25:46.000Z | 2021-04-16T19:25:46.000Z | tests/test_cryptocurrencychart.py | gdoermann/cryptocurrencychart | 713dae89304c86599f4a14a6dbd40f2e21c77048 | [
"MIT"
]
| null | null | null | tests/test_cryptocurrencychart.py | gdoermann/cryptocurrencychart | 713dae89304c86599f4a14a6dbd40f2e21c77048 | [
"MIT"
]
| 1 | 2020-11-12T12:14:22.000Z | 2020-11-12T12:14:22.000Z | import datetime
import unittest
from cryptocurrencychart.api import CryptoCurrencyChartApi
class TestApi(unittest.TestCase):
def setUp(self) -> None:
self.reset()
def reset(self):
self.api = CryptoCurrencyChartApi()
def test_api_connection(self):
currencies = self.api.get_base_currencies()
self.assertTrue('USD' in currencies)
def test_set_base_currency(self):
self.api.set_base_currency('USD', validate=False)
self.assertEqual(self.api.BASE, 'USD')
self.api.set_base_currency('CZK', validate=True)
self.assertEqual(self.api.BASE, 'CZK')
self.assertRaises(ValueError, self.api.set_base_currency, 'GBALK', validate=True)
self.assertEqual(self.api.BASE, 'CZK')
self.api.set_base_currency('GBALK', validate=False)
self.assertEqual(self.api.BASE, 'GBALK')
self.api.set_base_currency('USD', validate=False)
self.assertEqual(self.api.BASE, 'USD')
self.reset()
def test_get_coins(self):
coins = self.api.get_coins()
self.assertIsNotNone(coins)
self.assertIsInstance(coins, list)
def test_view_coin(self):
btc = self.api.coin_dict.get('BTC')
response = self.api.view_coin(btc['id'], datetime.date.today() - datetime.timedelta(days=1), 'USD')
self.assertEqual(response['baseCurrency'], 'USD')
def test_view_coin_history(self):
btc = self.api.coin_dict.get('BTC')
end = datetime.date.today() - datetime.timedelta(days=1)
start = end - datetime.timedelta(days=30)
response = self.api.view_coin_history(btc['id'], start, end, 'USD')
self.assertEqual(response['baseCurrency'], 'USD')
| 37.304348 | 107 | 0.666084 |
f70261b694fca9802548a912f945ff89a5035eca | 2,782 | py | Python | src/state.py | xeust/Method-Draw | a8b264e37fdc3a3a8b629178d62ecb6c8008760b | [
"MIT"
]
| 7 | 2021-07-25T23:38:31.000Z | 2021-12-04T23:11:57.000Z | src/state.py | xeust/Method-Draw | a8b264e37fdc3a3a8b629178d62ecb6c8008760b | [
"MIT"
]
| null | null | null | src/state.py | xeust/Method-Draw | a8b264e37fdc3a3a8b629178d62ecb6c8008760b | [
"MIT"
]
| 5 | 2021-08-11T12:02:10.000Z | 2022-02-24T04:41:09.000Z | import os
from deta import Deta
from datetime import date, datetime
from fastapi import HTTPException
import urllib
import base64
deta = Deta()
base = deta.Base("drawings")
drive = deta.Drive("drawings")
def get_all(db, query):
blob_gen = db.fetch(query)
blobs = []
for stored_blob in blob_gen:
for blob in stored_blob:
blobs.append(blob)
return blobs
# list all drawings
def get_drawings():
try:
return get_all(base, {})
except:
return None
# save existing drawing
def save(name, file):
encoded_name = str(base64.urlsafe_b64encode(name.encode("utf-8")), 'utf-8')
b = base.get(encoded_name)
try:
if (b):
base.put({"key": encoded_name, "name": name, "public": b["public"], "lastModified": datetime.utcnow().timestamp()})
return drive.put(name, file)
base.put({"key":encoded_name, "name": name, "public": False, "lastModified": datetime.utcnow().timestamp()})
return drive.put(name, file)
except:
return None
# save
def save_as(name, file, overwrite):
encoded_name = str(base64.urlsafe_b64encode(name.encode("utf-8")), 'utf-8')
b = base.get(encoded_name)
record = {"key": encoded_name, "name":name, "public": False, 'lastModified': datetime.utcnow().timestamp()}
if (overwrite or not b): # Overwrite allowed or Record Does not Exist
base.put(record)
drive.put(name, file)
return record
else: # Overwrite False and Record Exists
return None
def get_drawing(name):
encoded_name = str(base64.urlsafe_b64encode(name.encode("utf-8")), 'utf-8')
b = base.get(encoded_name)
d = drive.get(name)
if (b and d):
return d.read()
base.delete(encoded_name)
drive.delete(name)
return None
def get_metadata(name):
encoded_name = str(base64.urlsafe_b64encode(name.encode("utf-8")), 'utf-8')
b = base.get(encoded_name)
if (b):
return b
return None
def delete_drawing(name):
encoded_name = str(base64.urlsafe_b64encode(name.encode("utf-8")), 'utf-8')
try:
base.delete(encoded_name)
drive.delete(name)
return name
except:
return None
def modify_public(name, public):
encoded_name = str(base64.urlsafe_b64encode(name.encode("utf-8")), 'utf-8')
try:
b = base.get(encoded_name)
if (b):
b["public"] = public
return base.put(b)
return None
except:
return None
def get_public_drawing(name):
encoded_name = str(base64.urlsafe_b64encode(name.encode("utf-8")), 'utf-8')
try:
b = base.get(encoded_name)
if (b and b["public"]):
return drive.get(name)
return None
except:
return None | 27.82 | 127 | 0.62509 |
cb8d53a3ab59cdae86918dbce66c63400639164e | 3,478 | py | Python | test_intensity.py | gfzriesgos/deus | afa2b64d85a2da61025c9c7bfd253ea9572cfaed | [
"Apache-2.0"
]
| 1 | 2019-08-13T05:19:07.000Z | 2019-08-13T05:19:07.000Z | test_intensity.py | gfzriesgos/deus | afa2b64d85a2da61025c9c7bfd253ea9572cfaed | [
"Apache-2.0"
]
| 19 | 2019-10-16T12:50:57.000Z | 2022-03-11T23:58:20.000Z | test_intensity.py | gfzriesgos/deus | afa2b64d85a2da61025c9c7bfd253ea9572cfaed | [
"Apache-2.0"
]
| null | null | null | #!/usr/bin/env python3
# Copyright © 2021 Helmholtz Centre Potsdam GFZ German Research Centre for Geosciences, Potsdam, Germany
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
"""
Test cases for the intensity classes.
"""
import unittest
import intensityprovider
import testimplementations
class TestIntensity(unittest.TestCase):
"""
Unit test class for intensity related classes.
"""
def test_always_the_same_intensity_provider(self):
"""
Tests an test implementation which always
returns the same values regardless of
the coordinates.
"""
intensity_provider = testimplementations.AlwaysTheSameIntensityProvider(
kind="PGA", value=1.0, unit="g"
)
intensities, units = intensity_provider.get_nearest(1, 1)
self.assertLess(0.9, intensities["PGA"])
self.assertLess(intensities["PGA"], 1.1)
self.assertEqual(units["PGA"], "g")
intensities2, units2 = intensity_provider.get_nearest(180, 90)
self.assertEqual(intensities, intensities2)
self.assertEqual(units, units2)
def test_alias_intensity_provider(self):
"""
Test for aliases.
"""
inner_intensity_provider = testimplementations.AlwaysTheSameIntensityProvider(
kind="PGA", value=1.0, unit="g"
)
intensity_provider = intensityprovider.AliasIntensityProvider(
inner_intensity_provider,
aliases={
"SA_01": ["PGA"],
"SA_03": ["PGA"],
"ID": ["mwh"],
},
)
intensities, units = intensity_provider.get_nearest(1, 1)
for kind in ["PGA", "SA_01", "SA_03"]:
self.assertLess(0.9, intensities[kind])
self.assertLess(intensities[kind], 1.1)
self.assertEqual(units[kind], "g")
self.assertNotIn("mwh", intensities.keys())
self.assertNotIn("ID", intensities.keys())
def test_conversion_intensity_provider(self):
"""
Test for intensity conversion.
"""
inner_intensity_provider = testimplementations.AlwaysTheSameIntensityProvider(
kind="PGA", value=1.0, unit="g"
)
def pga_to_pga1000(old_intensity, old_unit):
return old_intensity / 1000, "g/1000"
intensity_provider = intensityprovider.ConversionIntensityProvider(
inner_intensity_provider,
from_intensity="PGA",
as_intensity="PGA/1000",
fun=pga_to_pga1000,
)
intensities, units = intensity_provider.get_nearest(1, 1)
self.assertLess(0.9, intensities["PGA"])
self.assertLess(intensities["PGA"], 1.1)
self.assertEqual(units["PGA"], "g")
self.assertLess(0.0009, intensities["PGA/1000"])
self.assertLess(intensities["PGA/1000"], 0.0011)
self.assertEqual(units["PGA/1000"], "g/1000")
if __name__ == "__main__":
unittest.main()
| 32.203704 | 307 | 0.646636 |
72d6e33e9aea04291de93db45045ada6e05f8668 | 3,702 | py | Python | NoteBooks/Curso de Python/Python/Examples/High_Patterns/ex36.py | Alejandro-sin/Learning_Notebooks | 161d6bed4c7b1d171b45f61c0cc6fa91e9894aad | [
"MIT"
]
| 1 | 2021-02-26T13:12:22.000Z | 2021-02-26T13:12:22.000Z | NoteBooks/Curso de Python/Python/Examples/High_Patterns/ex36.py | Alejandro-sin/Learning_Notebooks | 161d6bed4c7b1d171b45f61c0cc6fa91e9894aad | [
"MIT"
]
| null | null | null | NoteBooks/Curso de Python/Python/Examples/High_Patterns/ex36.py | Alejandro-sin/Learning_Notebooks | 161d6bed4c7b1d171b45f61c0cc6fa91e9894aad | [
"MIT"
]
| null | null | null | #Designing and Debuggin
# 1. Tod if debe llevar un else
# 2.No nestear mas de 2 if
# 3. Tratar los if como parrrafos. donde el if elif else son juntamos como una serie de sentencias.
# 4. MI LÓGICA BOLEANA ENTRE MÁS SIMPLE DE ENTENDER MEJOR.
# No usar mucho el while-loop,
# El debugger es como un scan entero de una persona enferma, puede que no encuentres infromación útil y específica.
# La mjeor manera de debugguear es con la sentencia print().
# Seguir el principio " Code a litle, run a litle, fix a litle".
#■■■ TO DO LIST ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
# Cada habitación puede ser una función con una estructura de control diferente para practicar.
#Defino las variables de mi juego.
# La vida del jugador es una variable.
life = 3
def start():
print("""
■■■■■■■■■■■■■■■■■ BIENVENIDO GAREN
El príncipe Malzhar te ha capturado en una dimensión, para que decidas tu suerte...y tu escaza inteligencia
-El vacío cree puede tragarse al Honor- Pensaste, digno de un guerrero.
-No necesariamente de un sabio dijo en voz alta el príncipe Malzahar-. había escuchado tus pensamientos, tenías
que salir de allí, todos lso secretos de Demacia estaban en riesgo. Garen ve dos portales a lo lejos.
Escoge el portal A o B para escapar del pensamiento de Malzahar.
""")
selection = input("> ")
return first_choice(selection)
def first_choice(selection):
if selection == "A" or "a":
print("""Cuando entras al portal ves las llanuras de Jonia, a lo lejos y una sombra está parada en medio de la nada, y blande las
hojas plateadas de dos shurikens enormes Zed te mira, y el cielo se tiñe de rojo. Va a haber pelea. ¿Qué haces?
A. Te arrojas sobre él con tu espada giratoria
B. Tratas de razonar con Zed
""")
selection = input("> ")
return jonia_room(selection),
elif selection == "B" or "b":
print("""Cuando entras al portal ves las montañas negras de Noxus, a lo lejos se alza leviatán la fortaleza móvil de Swain, y está quieta,
sin embargo esta situación es mala, si te ven podrían eliminarte con sus cañones cuervo, pero si te infiltras,
podrías tener una oportuniddad, como ningún otra para acabar con Noxus desde su cabeza. ¿Qué haces?
A. Te infiltras en la fortaleza escalando sus muros.
B. Esperas todo el día para saber qué hacen.
""")
selection = input("> ")
return jonia_room(selection), life
else:
print("Aprende a escribir, Manco!")
def jonia_room(selection):
if selection == "A" or "a":
life = 2
print(f"""Zed es mucho más veloz que tu, y estás en su tierra. Te clava sus cuchillas sombra y pierdes 1 de vida.
Te quedan {life} vidas.
Ves venir al maestro ninja a toda velocidad.¿ Que haces?
A. Esperas pacientemente a que esté cerca y usas tu Ultimate
B. Te paras en posición defensiva y observas sus sombras.
""")
selection = input("> ")
if selection == "A" or "a" or "B" or "b":
print("Estabas muerto desde el principio, las sombras te devuelven a la prisión de Malzahar.")
return start()
else:
print("Aprende a escribir!!")
return life
## Porqué me está guardando la variable selecion como B?
def noxus_room():
pass
def game_over():
pass
def win():
pass
def run():
start()
if __name__ == '__main__':
run() | 35.257143 | 146 | 0.619395 |
35d2f48900071cbafbeae60dcd2f92fde37c5f3a | 1,002 | py | Python | dataset/scannetv2/scannet_util.py | Hao-FANG-92/PointGroup | 62b2371a1ca3acf313357011ecf85543b03a12ec | [
"Apache-2.0"
]
| 219 | 2020-05-02T07:36:34.000Z | 2021-05-19T07:24:51.000Z | dataset/scannetv2/scannet_util.py | dongzhenwhu/PointGroup | a41c2cd22808861f0d4986b2825875c10bb661e5 | [
"Apache-2.0"
]
| 41 | 2020-05-06T10:17:42.000Z | 2021-05-13T07:46:30.000Z | dataset/scannetv2/scannet_util.py | dongzhenwhu/PointGroup | a41c2cd22808861f0d4986b2825875c10bb661e5 | [
"Apache-2.0"
]
| 46 | 2020-05-07T02:18:39.000Z | 2021-05-18T07:55:37.000Z | g_label_names = ['unannotated', 'wall', 'floor', 'chair', 'table', 'desk', 'bed', 'bookshelf', 'sofa', 'sink', 'bathtub', 'toilet', 'curtain', 'counter', 'door', 'window', 'shower curtain', 'refridgerator', 'picture', 'cabinet', 'otherfurniture']
def get_raw2scannetv2_label_map():
lines = [line.rstrip() for line in open('scannetv2-labels.combined.tsv')]
lines_0 = lines[0].split('\t')
print(lines_0)
print(len(lines))
lines = lines[1:]
raw2scannet = {}
for i in range(len(lines)):
label_classes_set = set(g_label_names)
elements = lines[i].split('\t')
raw_name = elements[1]
if (elements[1] != elements[2]):
print('{}: {} {}'.format(i, elements[1], elements[2]))
nyu40_name = elements[7]
if nyu40_name not in label_classes_set:
raw2scannet[raw_name] = 'unannotated'
else:
raw2scannet[raw_name] = nyu40_name
return raw2scannet
g_raw2scannetv2 = get_raw2scannetv2_label_map()
| 41.75 | 246 | 0.620758 |
0c9d70c2e8df4dabb2d109b1e65bf75d52483e28 | 32,368 | py | Python | moe/optimal_learning/python/cpp_wrappers/knowledge_gradient_mcmc.py | misokg/Cornell-MOE | 1547d6b168b7fc70857d522baa0d5d45c41d3cdf | [
"Apache-2.0"
]
| 218 | 2017-10-14T03:54:00.000Z | 2022-03-25T14:48:38.000Z | moe/optimal_learning/python/cpp_wrappers/knowledge_gradient_mcmc.py | Tracy3370/Cornell-MOE | df299d1be882d2af9796d7a68b3f9505cac7a53e | [
"Apache-2.0"
]
| 45 | 2017-09-27T14:33:31.000Z | 2020-12-16T09:32:50.000Z | moe/optimal_learning/python/cpp_wrappers/knowledge_gradient_mcmc.py | Tracy3370/Cornell-MOE | df299d1be882d2af9796d7a68b3f9505cac7a53e | [
"Apache-2.0"
]
| 63 | 2017-09-25T14:23:57.000Z | 2022-03-17T01:41:42.000Z | # -*- coding: utf-8 -*-
"""Tools to compute KnowledgeGradient and optimize the next best point(s) to sample using KG through C++ calls.
This file contains a class to compute Knowledge Gradient + derivatives and a functions to solve the q,p-KG optimization problem.
The :class:`moe.optimal_learning.python.cpp_wrappers.knowledge_gradient.KnowledgeGradient`
The optimization functions are convenient wrappers around the matching C++ calls.
See gpp_knowledge_gradient_optimization.hpp/cpp for further details on knowledge gradient.
"""
from __future__ import division
from builtins import zip
from builtins import object
from past.utils import old_div
import copy
import numpy
import moe.build.GPP as C_GP
from moe.optimal_learning.python.constant import DEFAULT_EXPECTED_IMPROVEMENT_MC_ITERATIONS, DEFAULT_MAX_NUM_THREADS
import moe.optimal_learning.python.cpp_wrappers.cpp_utils as cpp_utils
from moe.optimal_learning.python.interfaces.optimization_interface import OptimizableInterface
class PosteriorMeanMCMC(OptimizableInterface):
def __init__(
self,
gaussian_process_list,
num_fidelity,
points_to_sample=None,
randomness=None,
):
self._gaussian_process_list = gaussian_process_list
self._num_fidelity = num_fidelity
if points_to_sample is None:
self._points_to_sample = numpy.zeros((1, self._gaussian_process_list[0].dim))
if randomness is None:
self._randomness = C_GP.RandomnessSourceContainer(1) # create randomness for only 1 thread
# Set seed based on less repeatable factors (e.g,. time)
self._randomness.SetRandomizedUniformGeneratorSeed(0)
self._randomness.SetRandomizedNormalRNGSeed(0)
else:
self._randomness = randomness
self.objective_type = None # Not used for KG, but the field is expected in C++
@property
def dim(self):
"""Return the number of spatial dimensions."""
return self._gaussian_process_list[0].dim
@property
def problem_size(self):
"""Return the number of independent parameters to optimize."""
return self.dim-self._num_fidelity
def get_current_point(self):
"""Get the current_point (array of float64 with shape (problem_size)) at which this object is evaluating the objective function, ``f(x)``."""
return numpy.copy(self._points_to_sample)
def set_current_point(self, points_to_sample):
"""Set current_point to the specified point; ordering must match.
:param points_to_sample: current_point at which to evaluate the objective function, ``f(x)``
:type points_to_sample: array of float64 with shape (problem_size)
"""
self._points_to_sample = numpy.copy(numpy.atleast_2d(points_to_sample))
current_point = property(get_current_point, set_current_point)
def compute_posterior_mean_mcmc(self, force_monte_carlo=False):
r"""Compute the knowledge gradient at ``points_to_sample``, with ``points_being_sampled`` concurrent points being sampled.
.. Note:: These comments were copied from
:meth:`moe.optimal_learning.python.interfaces.expected_improvement_interface.ExpectedImprovementInterface.compute_expected_improvement`
``points_to_sample`` is the "q" and ``points_being_sampled`` is the "p" in q,p-EI.
Computes the knowledge gradient ``EI(Xs) = E_n[[f^*_n(X) - min(f(Xs_1),...,f(Xs_m))]^+]``, where ``Xs``
are potential points to sample (union of ``points_to_sample`` and ``points_being_sampled``) and ``X`` are
already sampled points. The ``^+`` indicates that the expression in the expectation evaluates to 0 if it
is negative. ``f^*(X)`` is the MINIMUM over all known function evaluations (``points_sampled_value``),
whereas ``f(Xs)`` are *GP-predicted* function evaluations.
In words, we are computing the knowledge gradient (over the current ``best_so_far``, best known
objective function value) that would result from sampling (aka running new experiments) at
``points_to_sample`` with ``points_being_sampled`` concurrent/ongoing experiments.
In general, the EI expression is complex and difficult to evaluate; hence we use Monte-Carlo simulation to approximate it.
When faster (e.g., analytic) techniques are available, we will prefer them.
The idea of the MC approach is to repeatedly sample at the union of ``points_to_sample`` and
``points_being_sampled``. This is analogous to gaussian_process_interface.sample_point_from_gp,
but we sample ``num_union`` points at once:
``y = \mu + Lw``
where ``\mu`` is the GP-mean, ``L`` is the ``chol_factor(GP-variance)`` and ``w`` is a vector
of ``num_union`` draws from N(0, 1). Then:
``improvement_per_step = max(max(best_so_far - y), 0.0)``
Observe that the inner ``max`` means only the smallest component of ``y`` contributes in each iteration.
We compute the improvement over many random draws and average.
:param force_monte_carlo: whether to force monte carlo evaluation (vs using fast/accurate analytic eval when possible)
:type force_monte_carlo: boolean
:return: the knowledge gradient from sampling ``points_to_sample`` with ``points_being_sampled`` concurrent experiments
:rtype: float64
"""
posterior_mean_mcmc = 0
for gp in self._gaussian_process_list:
posterior_mean_mcmc += C_GP.compute_posterior_mean(
gp._gaussian_process,
self._num_fidelity,
cpp_utils.cppify(self._points_to_sample),
)
return old_div(posterior_mean_mcmc,len(self._gaussian_process_list))
compute_objective_function = compute_posterior_mean_mcmc
def compute_grad_posterior_mean_mcmc(self, force_monte_carlo=False):
r"""Compute the gradient of knowledge gradient at ``points_to_sample`` wrt ``points_to_sample``, with ``points_being_sampled`` concurrent samples.
.. Note:: These comments were copied from
:meth:`moe.optimal_learning.python.interfaces.expected_improvement_interface.ExpectedImprovementInterface.compute_grad_expected_improvement`
``points_to_sample`` is the "q" and ``points_being_sampled`` is the "p" in q,p-EI.
In general, the expressions for gradients of EI are complex and difficult to evaluate; hence we use
Monte-Carlo simulation to approximate it. When faster (e.g., analytic) techniques are available, we will prefer them.
The MC computation of grad EI is similar to the computation of EI (decsribed in
compute_expected_improvement). We differentiate ``y = \mu + Lw`` wrt ``points_to_sample``;
only terms from the gradient of ``\mu`` and ``L`` contribute. In EI, we computed:
``improvement_per_step = max(max(best_so_far - y), 0.0)``
and noted that only the smallest component of ``y`` may contribute (if it is > 0.0).
Call this index ``winner``. Thus in computing grad EI, we only add gradient terms
that are attributable to the ``winner``-th component of ``y``.
:param force_monte_carlo: whether to force monte carlo evaluation (vs using fast/accurate analytic eval when possible)
:type force_monte_carlo: boolean
:return: gradient of EI, ``\pderiv{EI(Xq \cup Xp)}{Xq_{i,d}}`` where ``Xq`` is ``points_to_sample``
and ``Xp`` is ``points_being_sampled`` (grad EI from sampling ``points_to_sample`` with
``points_being_sampled`` concurrent experiments wrt each dimension of the points in ``points_to_sample``)
:rtype: array of float64 with shape (num_to_sample, dim)
"""
grad_posterior_mean_mcmc = numpy.zeros((1, self.dim-self._num_fidelity))
for gp in self._gaussian_process_list:
temp = C_GP.compute_grad_posterior_mean(
gp._gaussian_process,
self._num_fidelity,
cpp_utils.cppify(self._points_to_sample),
)
grad_posterior_mean_mcmc += cpp_utils.uncppify(temp, (1, self.dim-self._num_fidelity))
return old_div(grad_posterior_mean_mcmc,len(self._gaussian_process_list))
compute_grad_objective_function = compute_grad_posterior_mean_mcmc
def compute_hessian_objective_function(self, **kwargs):
"""We do not currently support computation of the (spatial) hessian of knowledge gradient."""
raise NotImplementedError('Currently we cannot compute the hessian of knowledge gradient.')
class GaussianProcessMCMC(object):
r"""Implementation of a pointer to GaussianProcess MCMC object in C++
"""
def __init__(self, hyperparameters_list, noise_variance_list, historical_data, derivatives):
"""Construct a GaussianProcess object that knows how to call C++ for evaluation of member functions.
:param covariance_function: covariance object encoding assumptions about the GP's behavior on our data
:type covariance_function: :class:`moe.optimal_learning.python.interfaces.covariance_interface.CovarianceInterface` subclass
(e.g., from :mod:`moe.optimal_learning.python.cpp_wrappers.covariance`).
:param historical_data: object specifying the already-sampled points, the objective value at those points, and the noise variance associated with each observation
:type historical_data: :class:`moe.optimal_learning.python.data_containers.HistoricalData` object
"""
self._hyperparameters_list = copy.deepcopy(hyperparameters_list)
self._num_mcmc = hyperparameters_list.shape[0]
self._historical_data = copy.deepcopy(historical_data)
self._noise_variance_list = copy.deepcopy(noise_variance_list)
self._derivatives = copy.deepcopy(derivatives)
self._num_derivatives = len(cpp_utils.cppify(self._derivatives))
# C++ will maintain its own copy of the contents of hyperparameters and historical_data
self._gaussian_process_mcmc = C_GP.GaussianProcessMCMC(
cpp_utils.cppify(self._hyperparameters_list),
cpp_utils.cppify(self._noise_variance_list),
cpp_utils.cppify(self._historical_data.points_sampled),
cpp_utils.cppify(self._historical_data.points_sampled_value),
cpp_utils.cppify(self._derivatives),
self._num_mcmc, self._num_derivatives,
self._historical_data.dim,
self._historical_data.num_sampled,
)
@property
def dim(self):
"""Return the number of spatial dimensions."""
return self._historical_data.dim
@property
def num_sampled(self):
"""Return the number of sampled points."""
return self._historical_data.num_sampled
@property
def num_derivatives(self):
return self._num_derivatives
@property
def derivatives(self):
return numpy.copy(self._derivatives)
@property
def noise_variance_list(self):
"""
Return the noise variance of the observations
:return:
"""
return numpy.copy(self._noise_variance_list)
@property
def _points_sampled_value(self):
"""Return the function values measured at each of points_sampled; see :class:`moe.optimal_learning.python.data_containers.HistoricalData`."""
return numpy.copy(self._historical_data.points_sampled_value)
@property
def _points_sampled(self):
"""return the points sampled"""
return numpy.copy(self._historical_data.points_sampled)
def get_historical_data_copy(self):
"""Return the data (points, function values, noise) specifying the prior of the Gaussian Process.
:return: object specifying the already-sampled points, the objective value at those points, and the noise variance associated with each observation
:rtype: data_containers.HistoricalData
"""
return copy.deepcopy(self._historical_data)
def multistart_knowledge_gradient_mcmc_optimization(
kg_optimizer,
inner_optimizer,
num_multistarts,
discrete_pts,
num_to_sample,
num_pts,
randomness=None,
max_num_threads=DEFAULT_MAX_NUM_THREADS,
status=None,
):
"""Solve the q,p-KG problem, returning the optimal set of q points to sample CONCURRENTLY in future experiments.
.. NOTE:: The following comments are copied from gpp_math.hpp, ComputeOptimalPointsToSample().
These comments are copied into
:func:`moe.optimal_learning.python.python_version.expected_improvement.multistart_expected_improvement_optimization`
This is the primary entry-point for EI optimization in the optimal_learning library. It offers our best shot at
improving robustness by combining higher accuracy methods like gradient descent with fail-safes like random/grid search.
Returns the optimal set of q points to sample CONCURRENTLY by solving the q,p-EI problem. That is, we may want to run 4
experiments at the same time and maximize the EI across all 4 experiments at once while knowing of 2 ongoing experiments
(4,2-EI). This function handles this use case. Evaluation of q,p-EI (and its gradient) for q > 1 or p > 1 is expensive
(requires monte-carlo iteration), so this method is usually very expensive.
Compared to ComputeHeuristicPointsToSample() (``gpp_heuristic_expected_improvement_optimization.hpp``), this function
makes no external assumptions about the underlying objective function. Instead, it utilizes a feature of the
GaussianProcess that allows the GP to account for ongoing/incomplete experiments.
If ``num_to_sample = 1``, this is the same as ComputeOptimalPointsToSampleWithRandomStarts().
The option of using GPU to compute general q,p-EI via MC simulation is also available. To enable it, make sure you have
installed GPU components of MOE, otherwise, it will throw Runtime excpetion.
:param kg_optimizer: object that optimizes (e.g., gradient descent, newton) EI over a domain
:type kg_optimizer: cpp_wrappers.optimization.*Optimizer object
:param num_multistarts: number of times to multistart ``ei_optimizer`` (UNUSED, data is in ei_optimizer.optimizer_parameters)
:type num_multistarts: int > 0
:param num_to_sample: how many simultaneous experiments you would like to run (i.e., the q in q,p-EI)
:type num_to_sample: int >= 1
:param use_gpu: set to True if user wants to use GPU for MC simulation
:type use_gpu: bool
:param which_gpu: GPU device ID
:type which_gpu: int >= 0
:param randomness: RNGs used by C++ to generate initial guesses and as the source of normal random numbers when monte-carlo is used
:type randomness: RandomnessSourceContainer (C++ object; e.g., from C_GP.RandomnessSourceContainer())
:param max_num_threads: maximum number of threads to use, >= 1
:type max_num_threads: int > 0
:param status: (output) status messages from C++ (e.g., reporting on optimizer success, etc.)
:type status: dict
:return: point(s) that maximize the knowledge gradient (solving the q,p-KG problem)
:rtype: array of float64 with shape (num_to_sample, ei_optimizer.objective_function.dim)
"""
# Create enough randomness sources if none are specified.
if randomness is None:
randomness = C_GP.RandomnessSourceContainer(max_num_threads)
# Set seeds based on less repeatable factors (e.g,. time)
randomness.SetRandomizedUniformGeneratorSeed(0)
randomness.SetRandomizedNormalRNGSeed(0)
randomness.SetNormalRNGSeedPythonList([314]*max_num_threads, [True]*max_num_threads)
# status must be an initialized dict for the call to C++.
if status is None:
status = {}
best_points_to_sample = C_GP.multistart_knowledge_gradient_mcmc_optimization(
kg_optimizer.optimizer_parameters,
inner_optimizer.optimizer_parameters,
kg_optimizer.objective_function._gaussian_process_mcmc._gaussian_process_mcmc,
kg_optimizer.objective_function._num_fidelity,
[float(x) for x in cpp_utils.cppify(kg_optimizer.domain.domain_bounds)],
cpp_utils.cppify(numpy.array(discrete_pts)),
cpp_utils.cppify(kg_optimizer.objective_function._points_being_sampled),
num_pts, num_to_sample, kg_optimizer.objective_function.num_being_sampled,
cpp_utils.cppify(numpy.array(kg_optimizer.objective_function._best_so_far_list)),
kg_optimizer.objective_function._num_mc_iterations,
max_num_threads,
randomness,
status,
)
# reform output to be a list of dim-dimensional points, dim = len(self.domain)
return cpp_utils.uncppify(best_points_to_sample, (num_to_sample, kg_optimizer.objective_function.dim))
class KnowledgeGradientMCMC(OptimizableInterface):
r"""Implementation of knowledge gradient computation via C++ wrappers: EI and its gradient at specified point(s) sampled from a GaussianProcess.
A class to encapsulate the computation of knowledge gradient and its spatial gradient using points sampled from an
associated GaussianProcess. The general EI computation requires monte-carlo integration; it can support q,p-EI optimization.
It is designed to work with any GaussianProcess.
.. Note:: Equivalent methods of ExpectedImprovementInterface and OptimizableInterface are aliased below (e.g.,
compute_expected_improvement and compute_objective_function, etc).
See :mod:`moe.optimal_learning.python.interfaces.expected_improvement_interface` docs for further details.
"""
def __init__(
self,
gaussian_process_mcmc,
gaussian_process_list,
num_fidelity,
inner_optimizer,
discrete_pts_list,
num_to_sample,
points_to_sample=None,
points_being_sampled=None,
num_mc_iterations=DEFAULT_EXPECTED_IMPROVEMENT_MC_ITERATIONS,
randomness=None,
):
"""Construct a KnowledgeGradient object that supports q,p-KG.
TODO(GH-56): Allow callers to pass in a source of randomness.
:param gaussian_process: GaussianProcess describing
:type gaussian_process: GaussianProcessMCMC class
:param discrete_pts: a discrete set of points to approximate the KG
:type discrete_pts: array of float64 with shape (num_pts, dim)
:param noise: measurement noise
:type noise: float64
:param points_to_sample: points at which to evaluate KG and/or its gradient to check their value in future experiments (i.e., "q" in q,p-KG)
:type points_to_sample: array of float64 with shape (num_to_sample, dim)
:param points_being_sampled: points being sampled in concurrent experiments (i.e., "p" in q,p-KG)
:type points_being_sampled: array of float64 with shape (num_being_sampled, dim)
:param num_mc_iterations: number of monte-carlo iterations to use (when monte-carlo integration is used to compute KG)
:type num_mc_iterations: int > 0
:param randomness: random source(s) used for monte-carlo integration (when applicable) (UNUSED)
:type randomness: (UNUSED)
"""
self._num_mc_iterations = num_mc_iterations
self._gaussian_process_mcmc = gaussian_process_mcmc
self._gaussian_process_list = gaussian_process_list
self._num_fidelity = num_fidelity
self._num_to_sample = num_to_sample
self._inner_optimizer = inner_optimizer
# self._num_derivatives = gaussian_process._historical_data.num_derivatives
self._discrete_pts_list = []
self._best_so_far_list = []
for discrete_pts, gaussian_process in zip(discrete_pts_list, self._gaussian_process_list):
self._discrete_pts_list.append(numpy.copy(discrete_pts))
mu_star = numpy.zeros(discrete_pts.shape[0])
for i, pt in enumerate(discrete_pts):
mu_star[i] = gaussian_process.compute_mean_of_additional_points(numpy.concatenate((pt, numpy.ones(self._num_fidelity))).reshape(1, self.dim))
self._best_so_far_list.append(numpy.amin(mu_star))
if points_being_sampled is None:
self._points_being_sampled = numpy.array([])
else:
self._points_being_sampled = numpy.copy(points_being_sampled)
if points_to_sample is None:
self._points_to_sample = numpy.zeros((self._num_to_sample, self._gaussian_process_list[0].dim))
else:
self._points_to_sample = points_to_sample
self._num_to_sample = self._points_to_sample.shape[0]
if randomness is None:
self._randomness = C_GP.RandomnessSourceContainer(1) # create randomness for only 1 thread
# Set seed based on less repeatable factors (e.g,. time)
self._randomness.SetRandomizedUniformGeneratorSeed(0)
self._randomness.SetRandomizedNormalRNGSeed(0)
else:
self._randomness = randomness
self.objective_type = None # Not used for KG, but the field is expected in C++
@property
def dim(self):
"""Return the number of spatial dimensions."""
return self._gaussian_process_mcmc.dim
@property
def num_to_sample(self):
"""Number of points at which to compute/optimize KG, aka potential points to sample in future experiments; i.e., the ``q`` in ``q,p-kg``."""
return self._points_to_sample.shape[0]
@property
def num_being_sampled(self):
"""Number of points being sampled in concurrent experiments; i.e., the ``p`` in ``q,p-KG``."""
return self._points_being_sampled.shape[0]
@property
def discrete(self):
return self._discrete_pts_list[0].shape[0]
@property
def problem_size(self):
"""Return the number of independent parameters to optimize."""
return self.num_to_sample * self.dim
def get_current_point(self):
"""Get the current_point (array of float64 with shape (problem_size)) at which this object is evaluating the objective function, ``f(x)``."""
return numpy.copy(self._points_to_sample)
def set_current_point(self, points_to_sample):
"""Set current_point to the specified point; ordering must match.
:param points_to_sample: current_point at which to evaluate the objective function, ``f(x)``
:type points_to_sample: array of float64 with shape (problem_size)
"""
self._points_to_sample = numpy.copy(numpy.atleast_2d(points_to_sample))
current_point = property(get_current_point, set_current_point)
def evaluate_at_point_list(
self,
points_to_evaluate,
randomness=None,
max_num_threads=DEFAULT_MAX_NUM_THREADS,
status=None,
):
"""Evaluate knowledge gradient (1,p-EI) over a specified list of ``points_to_evaluate``.
.. Note:: We use ``points_to_evaluate`` instead of ``self._points_to_sample`` and compute the EI at those points only.
``self._points_to_sample`` is unchanged.
Generally gradient descent is preferred but when they fail to converge this may be the only "robust" option.
This function is also useful for plotting or debugging purposes (just to get a bunch of EI values).
:param points_to_evaluate: points at which to compute EI
:type points_to_evaluate: array of float64 with shape (num_to_evaluate, self.dim)
:param randomness: RNGs used by C++ to generate initial guesses and as the source of normal random numbers when monte-carlo is used
:type randomness: RandomnessSourceContainer (C++ object; e.g., from C_GP.RandomnessSourceContainer())
:param max_num_threads: maximum number of threads to use, >= 1
:type max_num_threads: int > 0
:param status: (output) status messages from C++ (e.g., reporting on optimizer success, etc.)
:type status: dict
:return: EI evaluated at each of points_to_evaluate
:rtype: array of float64 with shape (points_to_evaluate.shape[0])
"""
# Create enough randomness sources if none are specified.
if randomness is None:
if max_num_threads == 1:
randomness = self._randomness
else:
randomness = C_GP.RandomnessSourceContainer(max_num_threads)
# Set seeds based on less repeatable factors (e.g,. time)
randomness.SetRandomizedUniformGeneratorSeed(0)
randomness.SetRandomizedNormalRNGSeed(0)
# status must be an initialized dict for the call to C++.
if status is None:
status = {}
# num_to_sample need not match ei_evaluator.num_to_sample since points_to_evaluate
# overrides any data inside ei_evaluator
num_to_evaluate, num_to_sample, _ = points_to_evaluate.shape
discrete_being_sampled = numpy.concatenate((numpy.ravel(self._discrete_pts_list), numpy.ravel(self._points_being_sampled)))
kg_values_mcmc = C_GP.evaluate_KG_mcmc_at_point_list(
self._gaussian_process_mcmc._gaussian_process_mcmc,
self._num_fidelity,
self._inner_optimizer.optimizer_parameters,
cpp_utils.cppify(self._inner_optimizer.domain.domain_bounds),
cpp_utils.cppify(discrete_being_sampled),
cpp_utils.cppify(points_to_evaluate),
num_to_evaluate,
self.discrete,
num_to_sample,
self.num_being_sampled,
cpp_utils.cppify(self._best_so_far_list),
self._num_mc_iterations,
max_num_threads,
randomness,
status,
)
return kg_values_mcmc
def compute_knowledge_gradient_mcmc(self, force_monte_carlo=False):
r"""Compute the knowledge gradient at ``points_to_sample``, with ``points_being_sampled`` concurrent points being sampled.
.. Note:: These comments were copied from
:meth:`moe.optimal_learning.python.interfaces.expected_improvement_interface.ExpectedImprovementInterface.compute_expected_improvement`
``points_to_sample`` is the "q" and ``points_being_sampled`` is the "p" in q,p-EI.
Computes the knowledge gradient ``EI(Xs) = E_n[[f^*_n(X) - min(f(Xs_1),...,f(Xs_m))]^+]``, where ``Xs``
are potential points to sample (union of ``points_to_sample`` and ``points_being_sampled``) and ``X`` are
already sampled points. The ``^+`` indicates that the expression in the expectation evaluates to 0 if it
is negative. ``f^*(X)`` is the MINIMUM over all known function evaluations (``points_sampled_value``),
whereas ``f(Xs)`` are *GP-predicted* function evaluations.
In words, we are computing the knowledge gradient (over the current ``best_so_far``, best known
objective function value) that would result from sampling (aka running new experiments) at
``points_to_sample`` with ``points_being_sampled`` concurrent/ongoing experiments.
In general, the EI expression is complex and difficult to evaluate; hence we use Monte-Carlo simulation to approximate it.
When faster (e.g., analytic) techniques are available, we will prefer them.
The idea of the MC approach is to repeatedly sample at the union of ``points_to_sample`` and
``points_being_sampled``. This is analogous to gaussian_process_interface.sample_point_from_gp,
but we sample ``num_union`` points at once:
``y = \mu + Lw``
where ``\mu`` is the GP-mean, ``L`` is the ``chol_factor(GP-variance)`` and ``w`` is a vector
of ``num_union`` draws from N(0, 1). Then:
``improvement_per_step = max(max(best_so_far - y), 0.0)``
Observe that the inner ``max`` means only the smallest component of ``y`` contributes in each iteration.
We compute the improvement over many random draws and average.
:param force_monte_carlo: whether to force monte carlo evaluation (vs using fast/accurate analytic eval when possible)
:type force_monte_carlo: boolean
:return: the knowledge gradient from sampling ``points_to_sample`` with ``points_being_sampled`` concurrent experiments
:rtype: float64
"""
knowledge_gradient_mcmc = C_GP.compute_knowledge_gradient_mcmc(
self._gaussian_process_mcmc._gaussian_process_mcmc,
self._num_fidelity,
self._inner_optimizer.optimizer_parameters,
[float(x) for x in cpp_utils.cppify(self._inner_optimizer.domain.domain_bounds)],
cpp_utils.cppify(self._discrete_pts_list),
cpp_utils.cppify(self._points_to_sample),
cpp_utils.cppify(self._points_being_sampled),
self.discrete,
self.num_to_sample,
self.num_being_sampled,
self._num_mc_iterations,
cpp_utils.cppify(self._best_so_far_list),
self._randomness,
)
return knowledge_gradient_mcmc
compute_objective_function = compute_knowledge_gradient_mcmc
def compute_grad_knowledge_gradient_mcmc(self, force_monte_carlo=False):
r"""Compute the gradient of knowledge gradient at ``points_to_sample`` wrt ``points_to_sample``, with ``points_being_sampled`` concurrent samples.
.. Note:: These comments were copied from
:meth:`moe.optimal_learning.python.interfaces.expected_improvement_interface.ExpectedImprovementInterface.compute_grad_expected_improvement`
``points_to_sample`` is the "q" and ``points_being_sampled`` is the "p" in q,p-EI.
In general, the expressions for gradients of EI are complex and difficult to evaluate; hence we use
Monte-Carlo simulation to approximate it. When faster (e.g., analytic) techniques are available, we will prefer them.
The MC computation of grad EI is similar to the computation of EI (decsribed in
compute_expected_improvement). We differentiate ``y = \mu + Lw`` wrt ``points_to_sample``;
only terms from the gradient of ``\mu`` and ``L`` contribute. In EI, we computed:
``improvement_per_step = max(max(best_so_far - y), 0.0)``
and noted that only the smallest component of ``y`` may contribute (if it is > 0.0).
Call this index ``winner``. Thus in computing grad EI, we only add gradient terms
that are attributable to the ``winner``-th component of ``y``.
:param force_monte_carlo: whether to force monte carlo evaluation (vs using fast/accurate analytic eval when possible)
:type force_monte_carlo: boolean
:return: gradient of EI, ``\pderiv{EI(Xq \cup Xp)}{Xq_{i,d}}`` where ``Xq`` is ``points_to_sample``
and ``Xp`` is ``points_being_sampled`` (grad EI from sampling ``points_to_sample`` with
``points_being_sampled`` concurrent experiments wrt each dimension of the points in ``points_to_sample``)
:rtype: array of float64 with shape (num_to_sample, dim)
"""
grad_knowledge_gradient_mcmc = C_GP.compute_grad_knowledge_gradient_mcmc(
self._gaussian_process_mcmc._gaussian_process_mcmc,
self._num_fidelity,
self._inner_optimizer.optimizer_parameters,
cpp_utils.cppify(self._inner_optimizer.domain.domain_bounds),
cpp_utils.cppify(self._discrete_pts_list),
cpp_utils.cppify(self._points_to_sample),
cpp_utils.cppify(self._points_being_sampled),
self.discrete,
self.num_to_sample,
self.num_being_sampled,
self._num_mc_iterations,
cpp_utils.cppify(self._best_so_far_list),
self._randomness,
)
return grad_knowledge_gradient_mcmc
compute_grad_objective_function = compute_grad_knowledge_gradient_mcmc
def compute_hessian_objective_function(self, **kwargs):
"""We do not currently support computation of the (spatial) hessian of knowledge gradient."""
raise NotImplementedError('Currently we cannot compute the hessian of knowledge gradient.')
| 51.871795 | 170 | 0.703473 |
338984409a4af271a4908270ea8774dda7a749a1 | 5,872 | py | Python | sem/wapiti.py | YoannDupont/SEM | ff21c5dc9a8e99eda81dc266e67cfa97dec7c243 | [
"MIT"
]
| 22 | 2016-11-13T21:08:58.000Z | 2021-04-26T07:04:54.000Z | sem/wapiti.py | Raphencoder/SEM | ff21c5dc9a8e99eda81dc266e67cfa97dec7c243 | [
"MIT"
]
| 15 | 2016-11-15T10:21:07.000Z | 2021-11-08T10:08:05.000Z | sem/wapiti.py | Raphencoder/SEM | ff21c5dc9a8e99eda81dc266e67cfa97dec7c243 | [
"MIT"
]
| 8 | 2016-11-15T10:21:41.000Z | 2022-03-04T21:28:05.000Z | # -*- coding: utf-8 -*-
"""
file: wapiti.py
Description: a very simple wrapper for calling wapiti. Provides train
and test procedures.
TODO: add every option for train and test
TODO: add support for other modes, such as dump and update (1.5.0+)
author: Yoann Dupont
MIT License
Copyright (c) 2018 Yoann Dupont
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import logging
import os.path
import subprocess
import time
import tarfile
from sem.logger import default_handler
from sem import SEM_HOME, SEM_EXT_DIR
from sem.misc import check_model_available
wapiti_logger = logging.getLogger("sem.wapiti")
wapiti_logger.addHandler(default_handler)
wapiti_logger.setLevel("INFO")
__command_name = os.path.join(SEM_EXT_DIR, "wapiti", "wapiti")
def command_name():
"""
returns the executable name of Wapiti.
This supposes that wapiti is installed on your computer.
"""
return __command_name
def train(inputfile, pattern=None, output=None, algorithm=None, nthreads=1, maxiter=None, rho1=None, rho2=None, model=None, compact=False):
"""
The train command of Wapiti.
"""
cmd = [command_name(), "train"]
if pattern is not None: cmd.extend(["-p", pattern])
if algorithm is not None: cmd.extend(["-a", str(algorithm)])
if nthreads > 1: cmd.extend(["-t", str(nthreads)])
if maxiter is not None: cmd.extend(["-i", str(maxiter)])
if rho1 is not None: cmd.extend(["-1", str(rho1)])
if rho2 is not None: cmd.extend(["-2", str(rho2)])
if model is not None: cmd.extend(["-m", str(model)])
if compact: cmd.append("-c")
cmd.append(str(inputfile))
if output is not None: cmd.append(str(output))
exit_status = subprocess.call(cmd)
if exit_status != 0:
if output is None: output = "*stdout"
raise RuntimeError("Wapiti exited with status {0}.\n{1:>6}: {2}\n{3:>6}: {4}\n{5:>6}: {6}".format(exit_status, "input", inputfile, "pattern", pattern, "output", output))
def label(input, model, output=None, only_labels=False, nbest=None):
"""
The label command of Wapiti.
"""
cmd = [command_name(), "label", "-m", str(model)]
if only_labels: cmd.extend(["-l"])
if nbest is not None: cmd.extend(["-n", str(nbest)])
cmd.append(input)
if output is not None: cmd.append(str(output))
exit_status = subprocess.call(cmd)
if exit_status != 0:
if output is None: output = "*stdout"
raise RuntimeError("%s exited with status %i.\n\tmodel: %s\n\tinput: %s\n\toutput: %s" %(command_name(), exit_status, model, input, output))
def label_corpus(corpus, model, field, encoding):
corpus_unicode = unicode(corpus).encode(encoding)
cmd = [command_name(), "label", "-m", model, "--label"]
wapiti_process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
w_stdout, w_stderr = wapiti_process.communicate(input=corpus_unicode)
i = 0
j = 0
corpus.fields.append(field)
for element in w_stdout.split("\n"):
element = element.strip()
if "" == element:
i += 1
j = 0
else:
corpus.sentences[i][j][field] = element
j += 1
def label_document(document, model, field, encoding, annotation_name=None, annotation_fields=None):
if annotation_fields is None:
fields = document.corpus.fields
else:
fields = annotation_fields
if annotation_name is None:
annotation_name = unicode(field)
check_model_available(model, logger=wapiti_logger)
corpus_unicode = document.corpus.unicode(fields).encode(encoding)
cmd = [command_name(), "label", "-m", model, "--label"]
wapiti_process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
w_stdout, w_stderr = wapiti_process.communicate(input=corpus_unicode)
try:
if wapiti_process.returncode != 0:
raise RuntimeError("%s exited with status %i" %(command_name(), wapiti_process.returncode))
except RuntimeError as rte:
for error_part in [line for line in w_stderr.split(u"\n") if line.strip() != ""]:
wapiti_logger.error(error_part)
wapiti_logger.exception(rte)
raise
i = 0
j = 0
tags = [[]]
w_stdout = w_stdout.decode(encoding)
document.corpus.fields.append(field)
for element in w_stdout.split(u"\n"):
element = element.strip()
if "" == element:
if len(tags[-1]) > 0:
tags.append([])
i += 1
j = 0
else:
tags[-1].append(element)
j += 1
tags = [t for t in tags if t]
document.add_annotation_from_tags(tags, field, annotation_name)
| 34.339181 | 177 | 0.65923 |
adb0599909d9a08e0e8a2aec9f300b741c0cd42f | 8,436 | py | Python | playground/examples/tf_simple_rule.py | minfawang/cs221-pommerman | e57126e3596a06144b8e9a83a1f4f6ff5404ee48 | [
"MIT"
]
| 1 | 2020-10-28T09:36:55.000Z | 2020-10-28T09:36:55.000Z | playground/examples/tf_simple_rule.py | minfawang/cs221-pommerman | e57126e3596a06144b8e9a83a1f4f6ff5404ee48 | [
"MIT"
]
| null | null | null | playground/examples/tf_simple_rule.py | minfawang/cs221-pommerman | e57126e3596a06144b8e9a83a1f4f6ff5404ee48 | [
"MIT"
]
| null | null | null | '''An example to show how to set up an pommerman game programmatically
Explanation of rewards:
# Suppose we have 4 agents, below may be a sequence of rewards after each step.
# Essentially the reward of an agent is: 0 if alive, -1 if dead, and +1 if
# you are the only one alive.
# reward = [0, 0, 0, 0]
# reward = [0, 0, 0, 0]
# reward = [0, 0, 0, -1]
# reward = [0, 0, -1, -1]
# reward = [-1, 1, -1, -1]
Run steps:
1) Create and update MODEL_DIR
2) Update other constants at the top:
* SHOULD_RENDER: If true, will render the game.
* NUM_EPISODES: Total training episodes.
* REPORT_EVERY_ITER: Print metric info every these iters.
* SAVE_EVERY_ITER: Save the model checkpoint to file every these iters.
'''
import pommerman
from pommerman.agents import SimpleAgent, BaseAgent
from pommerman.configs import ffa_v0_fast_env
from pommerman.envs.v0 import Pomme
import numpy as np
import collections
import copy
import os
import pickle
from tensorforce.agents import PPOAgent
from tensorforce.execution import Runner
from tensorforce.contrib.openai_gym import OpenAIGym
from feature_extractor import featurize_map
os.environ["CUDA_VISIBLE_DEVICES"] = "0" # This set the environment.
DEBUG = False
SHOULD_RENDER = False
NUM_EPISODES = 100000
MAX_EPISODE_TIMTESTAMPS = 2000
MODEL_DIR = '../model_dir/tf_simple_rule/'
REPORT_EVERY_ITER = 20
SAVE_EVERY_ITER = 100
reward_counter = collections.Counter()
episode_recorder = []
def get_win_loss(episode_recorder):
rewards = [t[-1] for t in episode_recorder]
wins = len([r for r in rewards if r > 0])
losses = len(rewards) - wins
return wins, losses
# Callback function printing episode statistics
def episode_finished(r):
global reward_counter, episode_recorder
reward = r.episode_rewards[-1]
reward_counter[reward] += 1
episode_recorder.append([r.episode, r.episode_timestep, reward])
if r.episode % REPORT_EVERY_ITER == 0:
print("Finished episode {ep} after {ts} timesteps (reward: {reward})".format(
ep=r.episode, ts=r.episode_timestep, reward=reward))
wins, losses = get_win_loss(episode_recorder[-REPORT_EVERY_ITER:])
print('Episode win/loss: {}/{}, rate:{}'.format(wins, losses, float(wins)/losses))
wins, losses = get_win_loss(episode_recorder)
print('Overall win/loss: {}/{}, rate:{}'.format(wins, losses, float(wins)/losses))
if r.episode % SAVE_EVERY_ITER == 0:
print('saving model ...')
r.agent.save_model(MODEL_DIR)
print('reward_counter ...')
with open(os.path.join(MODEL_DIR, 'reward_counter.p'), 'wb') as fout:
pickle.dump(reward_counter, fout)
print('episode recorder ...')
with open(os.path.join(MODEL_DIR, 'episode_recorder.p'), 'wb') as fout:
pickle.dump(episode_recorder, fout)
return True
def dprint(*args, **kwargs):
if DEBUG:
print(*args, **kwargs)
# Debug logic
def get_actions_str(actions, agent_index):
actions_map = {
0: 'Stop',
1: 'Up',
2: 'Down',
3: 'Left',
4: 'Right',
5: 'Bomb',
}
action_strs = [actions_map[a] for a in actions]
action_strs[agent_index] = '[{}]'.format(action_strs[agent_index])
return 'all_actions: {}'.format(action_strs)
# TODO(minfa): Update agent reward
# if terminal and agent_alive (a.k.a. agent_reward == 1): reward += 500
# if agent is killed: reward = -500 + 0.5 * t
# if agent is dead for a while:
def compute_agent_reward(old_state, state, game_reward):
"""
Inputs:
old_state: Raw agent old state.
state: Raw agent state.
game_reward: Raw game reward with respect to the agent.
"""
reward = 0
if game_reward == 1:
reward = 1.0
elif game_reward == -1:
reward = -1.0
else:
old_num_alive = len(old_state['alive'])
new_num_alive = len(state['alive'])
dprint('alive old/new: ', old_num_alive, new_num_alive)
if new_num_alive < old_num_alive:
reward += 0.1
# [6, 7, 8] are special weapons.
# In the case below, the agent just eats a weapon.
position = state['position']
old_board_val = old_state['board'][position]
dprint('old board is new board: ', old_state['board'] is state['board'])
dprint('position: {}, old board val: {}'.format(position, old_board_val))
if old_board_val in [6, 7, 8]:
reward += 0.1
return reward
def featurize(obs):
feature_map = featurize_map(obs)
return np.concatenate(list(feature_map.values()))
class TensorforceAgent(BaseAgent):
def act(self, obs, action_space):
pass
def create_env_agent():
# Instantiate the environment
config = ffa_v0_fast_env()
env = Pomme(**config["env_kwargs"])
env.seed(0)
# Create a Proximal Policy Optimization agent
agent = PPOAgent(
states=dict(type='float', shape=(80)),
actions=dict(type='int', num_actions=env.action_space.n),
network=[
dict(type='dense', size=64),
dict(type='dense', size=64)
],
batching_capacity=1000,
step_optimizer=dict(
type='adam',
learning_rate=2e-4
),
# PGModel
baseline_mode='network',
baseline=dict(type='custom', network=[
dict(type='dense', size=64),
dict(type='dense', size=64)
]),
baseline_optimizer=dict(
type='adam',
learning_rate=2e-4
),
)
# Add 3 random agents
agents = []
for agent_id in range(3):
agents.append(SimpleAgent(config["agent"](agent_id, config["game_type"])))
# Add TensorforceAgent
agent_id += 1
agents.append(TensorforceAgent(config["agent"](agent_id, config["game_type"])))
env.set_agents(agents)
env.set_training_agent(agents[-1].agent_id)
env.set_init_game_state(None)
return (env, agent)
class WrappedEnv(OpenAIGym):
def __init__(self, gym, agent_reward_fn, visualize=False):
self.gym = gym
self.visualize = visualize
self.agent_reward_fn_ = agent_reward_fn
def set_agent_reward_fn(agent_reward_fn):
self.agent_reward_fn_ = agent_reward_fn
def execute(self, action):
if self.visualize:
self.gym.render()
actions = self.unflatten_action(action=action)
obs = self.gym.get_observations()
agent_old_state = copy.deepcopy(obs[self.gym.training_agent])
all_actions = self.gym.act(obs)
all_actions.insert(self.gym.training_agent, actions)
state, reward, terminal, _ = self.gym.step(all_actions)
agent_state = featurize(state[self.gym.training_agent])
agent_reward = reward[self.gym.training_agent]
agent_reward = self.agent_reward_fn_(
agent_old_state,
state[self.gym.training_agent],
agent_reward)
if DEBUG:
print(get_actions_str(all_actions, self.gym.training_agent))
print('agent_state, terminal, agent_reward: ',
state[self.gym.training_agent], terminal, agent_reward)
should_terminal = input('\n press any key to step forward (or "t" to terminal) \n')
if should_terminal == 't':
terminal = True
return agent_state, terminal, agent_reward
def reset(self):
obs = self.gym.reset()
agent_obs = featurize(obs[3])
return agent_obs
def main():
global reward_counter, episode_recorder
# Print all possible environments in the Pommerman registry
print(pommerman.REGISTRY)
# Create a set of agents (exactly four)
env, agent = create_env_agent()
try:
agent.restore_model(MODEL_DIR)
with open(os.path.join(MODEL_DIR, 'reward_counter.p'), 'rb') as fin:
reward_counter = pickle.load(fin)
with open(os.path.join(MODEL_DIR, 'episode_recorder.p'), 'rb') as fin:
episode_recorder = pickle.load(fin)
print('Loaded model from episode: ', agent.episode)
wins, losses = get_win_loss(episode_recorder)
print('Past win/loss: {}/{}'.format(wins, losses))
except Exception as e:
print(e)
print('training a new model')
wrapped_env = WrappedEnv(
env,
visualize=SHOULD_RENDER,
agent_reward_fn=compute_agent_reward,
)
runner = Runner(agent=agent, environment=wrapped_env)
runner.run(
episodes=NUM_EPISODES,
max_episode_timesteps=MAX_EPISODE_TIMTESTAMPS,
episode_finished=episode_finished,
)
try:
runner.close()
except AttributeError as e:
print('AttributeError: ', e)
if __name__ == '__main__':
main()
| 29.291667 | 93 | 0.671171 |
f160539d829cf341ab0064f6c09eef07b89da372 | 134 | py | Python | .history/myblog/feeds_20200416203822.py | abhinavmarwaha/demo-django-blog | c80a7d825e44d7e1589d9272c3583764562a2515 | [
"MIT"
]
| null | null | null | .history/myblog/feeds_20200416203822.py | abhinavmarwaha/demo-django-blog | c80a7d825e44d7e1589d9272c3583764562a2515 | [
"MIT"
]
| null | null | null | .history/myblog/feeds_20200416203822.py | abhinavmarwaha/demo-django-blog | c80a7d825e44d7e1589d9272c3583764562a2515 | [
"MIT"
]
| null | null | null | from django.contrib.syndication.views import Feed
from django.template.defaultfilters import truncatewords
from .models import Post
| 22.333333 | 56 | 0.850746 |
dcd5bdb960f41d5cf65e795e4d1de6c2a224eac4 | 1,832 | py | Python | data_structures/tree_traversal.py | johnnydevriese/python_fun | 01fc5fcc82c7c27e25eabff85a2e88f3554129fe | [
"MIT"
]
| null | null | null | data_structures/tree_traversal.py | johnnydevriese/python_fun | 01fc5fcc82c7c27e25eabff85a2e88f3554129fe | [
"MIT"
]
| null | null | null | data_structures/tree_traversal.py | johnnydevriese/python_fun | 01fc5fcc82c7c27e25eabff85a2e88f3554129fe | [
"MIT"
]
| null | null | null | # three traversals we will usual look at are:
# PREORDER: visit root node first, then recursively do a a preorder traversal of the left subtree.
# followed by a recursive preorder traversal of the right subtree.
# INORDER: we recursively do an inorder traversal on the left subtree, visit the root node,
# and finally do a recursive inorder traversal of the right subtree.
# POSTORDER: we recursively do a postorder traversal of the left subtree and the right subtree
# followed by a visit to the root node.
import operator
def preorder(tree):
if tree:
print(tree.getRootVal())
# go through all the left
preorder(tree.getLeftChild())
# then go through all of the right.
preorder(tree.getRightChild())
# could also put preorder as part of the BinaryTree class.
def preorder_class(self):
print(self.key)
if self.leftChild:
self.leftChild.preorder()
if self.rightChild:
self.rightChild.preorder()
# probably better to have preorder as an external function because we rarely want to just go through a BST.
def postordereval(tree):
opers = {'+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.truediv}
res1 = None
res2 = None
if tree:
res1 = postordereval(tree.getLeftChild())
res2 = postordereval(tree.getRightChild())
if res1 and res2:
return opers[tree.getRootVal()](res1, res2)
else:
return tree.getRootVal()
def inorder(tree):
if tree is not None:
inorder(tree.getLeftChild())
print(tree.getRootVal())
inorder(tree.getRightChild())
def printexp(tree):
sVal = ""
if tree:
sVal = '(' + printexp(tree.getLeftChild())
sVal = sVal + str(tree.getRootVal())
sVal = sVal + printexp(tree.getRightChild())+')'
return sVal | 30.533333 | 107 | 0.674127 |
810832ea2251a4e521c850c82844a70c9c8d0e1c | 1,215 | py | Python | src/address_gen.py | hexuscoin/hexus | 2ae02b8764776c67181e41b3f29c38da78e27095 | [
"MIT"
]
| null | null | null | src/address_gen.py | hexuscoin/hexus | 2ae02b8764776c67181e41b3f29c38da78e27095 | [
"MIT"
]
| null | null | null | src/address_gen.py | hexuscoin/hexus | 2ae02b8764776c67181e41b3f29c38da78e27095 | [
"MIT"
]
| null | null | null | # pip install base58 / ecdsa
# tested in python 3.6.5
import os, binascii, hashlib, base58, ecdsa
def ripemd160(x):
d = hashlib.new('ripemd160')
d.update(x)
return d
for n in range(1): # number of key pairs to generate`
# generate private key, uncompressed bitcoin WIF starts with "5"
priv_key = os.urandom(32)
fullkey = 'c1' + binascii.hexlify(priv_key).decode()
sha256a = hashlib.sha256(binascii.unhexlify(fullkey)).hexdigest()
sha256b = hashlib.sha256(binascii.unhexlify(sha256a)).hexdigest()
WIF = base58.b58encode(binascii.unhexlify(fullkey+sha256b[:8]))
# get public key, uncompressed bitcoin address starts with "1"
sk = ecdsa.SigningKey.from_string(priv_key, curve=ecdsa.SECP256k1)
vk = sk.get_verifying_key()
publ_key = '04' + binascii.hexlify(vk.to_string()).decode()
hash160 = ripemd160(hashlib.sha256(binascii.unhexlify(publ_key)).digest()).digest()
publ_addr_a = b"\x41" + hash160
checksum = hashlib.sha256(hashlib.sha256(publ_addr_a).digest()).digest()[:4]
publ_addr_b = base58.b58encode(publ_addr_a + checksum)
i = n + 1
print('Private Key : ' + WIF.decode())
print('Hexus Address : ' + publ_addr_b.decode())
| 39.193548 | 87 | 0.692181 |
0760f11c1b3fe8d109fd363f1000d5d8adef67e2 | 26,235 | py | Python | bigbench/bbseqio/bigbench_bridge_test.py | sarahadlerrous/BIG-bench | e71e63598538674cece60f8457475f8ddbdf785a | [
"Apache-2.0"
]
| null | null | null | bigbench/bbseqio/bigbench_bridge_test.py | sarahadlerrous/BIG-bench | e71e63598538674cece60f8457475f8ddbdf785a | [
"Apache-2.0"
]
| null | null | null | bigbench/bbseqio/bigbench_bridge_test.py | sarahadlerrous/BIG-bench | e71e63598538674cece60f8457475f8ddbdf785a | [
"Apache-2.0"
]
| null | null | null | # Copyright 2021 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.
"""Tests for bigbench_bridge."""
# pylint: disable=g-complex-comprehension
import collections
from absl.testing import absltest
from bigbench.api import json_task
from bigbench.api import task_metrics
from bigbench.api import util
from bigbench.api import json_utils
from bigbench.bbseqio import bigbench_bridge as bb
import numpy as np
from seqio import test_utils
mock = absltest.mock
class BigbenchBridgeTest(absltest.TestCase):
# Note: The ids below must be reproducible, hence used directly in tests.
def _get_train_split_ids(self):
return [
42, 41, 91, 9, 65, 50, 1, 70, 15, 78, 73, 10, 55, 56, 72, 45, 48, 92,
76, 37, 30, 21, 32, 96, 80, 49, 83, 26, 87, 33, 8, 47, 59, 63, 74, 44,
98, 52, 85, 12, 36, 23, 39, 40, 18, 66, 61, 60, 7, 34, 99, 46, 2, 51,
16, 38, 58, 68, 22, 62, 24, 5, 6, 67, 82, 19, 79, 43, 90, 20, 0, 95, 57,
93, 53, 89, 25, 71, 84, 77
]
def _get_validation_split_ids(self):
return [
64, 29, 27, 88, 97, 4, 54, 75, 11, 69, 86, 13, 17, 28, 31, 35, 94, 3,
14, 81
]
def _get_shuffled_validation_split_ids(self):
return [
31, 13, 17, 35, 86, 94, 29, 3, 75, 97, 88, 14, 4, 11, 54, 28, 81, 64,
27, 69
]
def _get_sampled_all_split_ids(self):
return [
83, 53, 70, 45, 44, 39, 22, 80, 10, 0, 18, 30, 73, 33, 90, 4, 76, 77,
12, 31, 55, 88, 26, 42, 69, 15, 40, 96, 9, 72, 11, 47, 85, 28, 93, 5,
66, 65, 35, 16, 49, 34, 7, 95, 27, 19, 81, 25, 62, 13
]
def _get_sampled_train_split_ids(self):
return [
8, 42, 32, 47, 76, 87, 73, 0, 65, 55, 34, 63, 43, 44, 90, 66, 93, 5, 38,
36, 78, 82, 50, 60, 74, 6, 39, 16, 48, 12, 58, 77, 70, 99
]
def _get_sampled_validation_split_ids(self):
return [64, 3, 35, 29, 11, 4, 13, 88, 14, 94, 28, 27, 69, 81, 97, 17]
def _get_shuffled_sampled_all_split_ids(self):
return [
53, 72, 97, 16, 55, 68, 18, 79, 27, 77, 47, 84, 17, 4, 34, 46, 88, 28,
52, 23, 7, 24, 50, 11, 85, 9, 78, 87, 29, 74, 82, 3, 99, 98, 89, 26, 81,
67, 71, 20, 8, 60, 63, 5, 94, 61, 80, 37, 42, 0
]
def _get_shuffled_sampled_train_split_ids(self):
return [
9, 22, 51, 52, 70, 90, 84, 39, 38, 74, 60, 76, 87, 48, 95, 99, 10, 30,
61, 92, 50, 67, 33, 43, 78, 65, 77, 80, 26, 15, 57, 96, 5, 18
]
def _get_shuffled_sampled_validation_split_ids(self):
return [13, 4, 29, 35, 17, 27, 75, 88, 31, 97, 14, 64, 86, 28, 3, 94]
def _flatten(self, nested_list):
return [elem for alist in nested_list for elem in alist]
def setUp(self):
super(BigbenchBridgeTest, self).setUp()
bb.BigBenchJsonTaskFetcher._BIGBENCH_JSON_TASKS.clear()
self.mock_bigbench_json_task = mock.create_autospec(json_task.JsonTask)
self.mock_bigbench_json_subtask = mock.create_autospec(json_task.JsonTask)
self.mock_bb_json_task_api = self.enter_context(
mock.patch.object(json_task, "JsonTask"))
self.mock_json_util = mock.create_autospec(json_utils.JsonUtils)
def test_bigbench_task_fetcher(self):
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
self.assertEqual(
self.mock_bigbench_json_task,
bb.BigBenchJsonTaskFetcher.get_bigbench_json_task(
task_name="test_task",
task_path="test/task/path.json",
json_util=self.mock_json_util,
format_fn=json_task.default_format_fn))
self.mock_bb_json_task_api.assert_called_once_with(
"test/task/path.json",
task_json_utils=mock.ANY,
format_fn=json_task.default_format_fn)
def test_bigbench_task_fetcher_singleton(self):
# fetch task multiple times.
for _ in range(10):
_ = bb.BigBenchJsonTaskFetcher.get_bigbench_json_task(
task_name="test_task",
task_path="test/task/path.json",
json_util=self.mock_json_util,
format_fn=json_task.default_format_fn)
# bigbench json api should be called only once.
self.mock_bb_json_task_api.assert_called_once_with(
"test/task/path.json",
task_json_utils=mock.ANY,
format_fn=json_task.default_format_fn)
def test_bigbench_subtask_fetcher(self):
self.mock_bigbench_json_subtask.name = "test_task:subtask"
self.mock_bigbench_json_task.name = "test_task"
self.mock_bigbench_json_task.subtasks = [self.mock_bigbench_json_subtask]
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
self.assertEqual(
self.mock_bigbench_json_subtask,
bb.BigBenchJsonTaskFetcher.get_bigbench_json_task_or_subtask(
task_name="test_task",
task_path="test/task/path.json",
subtask_name="subtask",
json_util=self.mock_json_util))
def test_get_dataset_fn_all_split(self):
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1)]
} for i in range(100)]
self.mock_bigbench_json_task.task_prefix = "prefix: "
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json")
ds = dataset_fn(split="all", shuffle_files=False)
expected = [{
"inputs": f"prefix: {i}",
"targets": str(i + 1),
"answers": [str(i + 1)],
} for i in range(100)]
test_utils.assert_dataset(ds, expected)
def test_get_dataset_fn_train_split(self):
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1), str(i + 2)]
} for i in range(100)]
self.mock_bigbench_json_task.task_prefix = "prefix: "
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json")
ds = dataset_fn(split="train", shuffle_files=False)
expected = [
[
{ # multiple targets are split into separate examples.
"inputs": f"prefix: {i}",
"targets": str(i + 1),
"idx": np.array([idx, 0])
},
{
"inputs": f"prefix: {i}",
"targets": str(i + 2),
"idx": np.array([idx, 1])
}
] for idx, i in enumerate(self._get_train_split_ids())
]
expected = self._flatten(expected)
test_utils.assert_dataset(ds, expected)
def test_get_dataset_fn_validation_split(self):
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1), str(i + 2)]
} for i in range(100)]
self.mock_bigbench_json_task.task_prefix = "prefix: "
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json")
ds = dataset_fn(split="validation", shuffle_files=False)
expected = [{ # multiple targets are not split into separate examples.
"inputs": f"prefix: {i}",
"targets": str(i + 1),
"answers": [str(i + 1), str(i + 2)],
} for i in self._get_validation_split_ids()]
test_utils.assert_dataset(ds, expected)
def test_get_dataset_fn_invalid_split(self):
# Setup mock BIG-bench task
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1)]
} for i in range(10)]
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task",
task_path="test/task/path.json",
)
with self.assertRaisesWithLiteralMatch(
ValueError,
"splits supported: ['all', 'train', 'validation'], got: test"):
_ = dataset_fn(split="test", shuffle_files=False)
def test_get_dataset_fn_ds_too_small(self):
# Setup mock BIG-bench task
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1)]
} for i in range(3)]
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json")
with self.assertRaisesRegex(
ValueError,
"Task: test_task, subtask: None, has too few examples: 3.*"):
_ = dataset_fn(split="validation", shuffle_files=False)
def test_get_dataset_fn_shuffle(self):
# Setup mock BIG-bench task
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1)]
} for i in range(100)]
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json")
ds = dataset_fn(split="validation", shuffle_files=True, seed=23)
expected = [{ # multiple targets are not split into separate examples.
"inputs": str(i),
"targets": str(i + 1),
"answers": [str(i + 1)],
} for i in self._get_shuffled_validation_split_ids()]
test_utils.assert_dataset(ds, expected)
def test_get_dataset_fn_max_examples(self):
# Setup mock BIG-bench task
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1)]
} for i in range(100)]
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json", max_examples=50)
ds_all = dataset_fn(split="all", shuffle_files=False)
ds_train = dataset_fn(split="train", shuffle_files=False)
ds_val = dataset_fn(split="validation", shuffle_files=False)
expected_all = [{
"inputs": str(i),
"targets": str(i + 1),
"answers": [str(i + 1)],
} for i in self._get_sampled_all_split_ids()]
expected_train = [{
"inputs": str(i),
"targets": str(i + 1),
"idx": np.array([idx, 0])
} for idx, i in enumerate(self._get_sampled_train_split_ids())]
expected_val = [{
"inputs": str(i),
"targets": str(i + 1),
"answers": [str(i + 1)],
} for i in self._get_sampled_validation_split_ids()]
test_utils.assert_dataset(ds_all, expected_all)
test_utils.assert_dataset(ds_train, expected_train)
test_utils.assert_dataset(ds_val, expected_val)
def test_get_dataset_fn_shuffle_max_examples(self):
# Setup mock BIG-bench task
self.mock_bigbench_json_task._ds = [{
"input": str(i),
"target": [str(i + 1)]
} for i in range(100)]
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json", max_examples=50)
ds_all = dataset_fn(split="all", shuffle_files=True, seed=23)
ds_train = dataset_fn(split="train", shuffle_files=True, seed=23)
ds_val = dataset_fn(split="validation", shuffle_files=True, seed=23)
expected_all = [{
"inputs": str(i),
"targets": str(i + 1),
"answers": [str(i + 1)],
} for i in self._get_shuffled_sampled_all_split_ids()]
expected_train = [{
"inputs": str(i),
"targets": str(i + 1),
"idx": np.array([idx, 0])
} for idx, i in enumerate(self._get_shuffled_sampled_train_split_ids())]
expected_val = [{
"inputs": str(i),
"targets": str(i + 1),
"answers": [str(i + 1)],
} for i in self._get_shuffled_sampled_validation_split_ids()]
test_utils.assert_dataset(ds_all, expected_all)
test_utils.assert_dataset(ds_train, expected_train)
test_utils.assert_dataset(ds_val, expected_val)
@mock.patch.object(util, "postprocess_output")
def test_get_postprocessing_fn_prediction(self, mock_postprocess_api):
self.mock_bigbench_json_task.stop_string = "a stop string"
self.mock_bigbench_json_task.output_regex = "a regex"
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
postprocess_fn = bb.get_postprocess_fn(
task_name="test_task", task_path="test/task/path.json")
_ = postprocess_fn("Some output", example=None, is_target=False)
mock_postprocess_api.assert_called_once_with(
"Some output",
max_length=None,
stop_string="a stop string",
output_regex="a regex")
@mock.patch.object(util, "postprocess_output")
def test_get_postprocessing_fn_gen_target(self, mock_bb_postprocess_api):
self.mock_bigbench_json_task.stop_string = "a stop string"
self.mock_bigbench_json_task.output_regex = "a regex"
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
postprocess_fn = bb.get_postprocess_fn(
task_name="test_task", task_path="test/task/path.json")
example = {
"inputs": np.array("some input"),
"targets": np.array("some output"),
"answers": np.array([b"some output 1", b"some output 2"])
}
postprocessed = postprocess_fn(
"Some output", example=example, is_target=True)
self.assertDictEqual(postprocessed, example)
# targets are not postprocessed.
mock_bb_postprocess_api.assert_not_called()
@mock.patch.object(util, "postprocess_output")
def test_get_postprocessing_fn_multiple_choice(self, mock_bb_postprocess_api):
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
postprocess_fn = bb.get_postprocess_fn(
task_name="test_task",
task_path="test/task/path.json",
bigbench_task_type=bb.BigBenchTaskType.MULTIPLE_CHOICE)
example = {
"idx": np.array([0, 1]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input",
"targets_pretokenized": b"some target",
"scores": 0.4
}
postprocessed = postprocess_fn(
"Some output", example=example, is_target=True)
self.assertDictEqual(postprocessed, example)
postprocessed = postprocess_fn(
"Some output", example=example, is_target=False)
self.assertEqual(postprocessed, "Some output")
mock_bb_postprocess_api.assert_not_called()
@mock.patch.object(task_metrics, "measure_generative_metrics")
def test_get_metric_fn_generative(self, mock_measure):
self.mock_bigbench_json_task.generative_metrics = ["metric1", "metric2"]
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
examples = [{
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input",
"targets_pretokenized": b"some target",
"answers": [b"some target"]
}]
metric_fn = bb.get_metric_fn(
task_name="test_task", task_path="test/task/path.json")
_ = metric_fn(examples, ["predictions"])
expected_samples = [
collections.OrderedDict([("input", "some input"),
("target", ["some target"]),
("generative_response", "predictions")])
]
mock_measure.assert_called_once_with(expected_samples,
["metric1", "metric2"])
@mock.patch.object(task_metrics, "measure_multiple_choice_metrics")
def test_get_metric_fn_multiple_choice(self, mock_measure):
self.mock_bigbench_json_task.multiple_choice_metrics = [
"metric1", "metric2"
]
self.mock_bigbench_json_task.absolute_normalization = False
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
examples = [{
"idx": np.array([0, 1]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input",
"targets_pretokenized": b"some target",
"scores": 0.4,
"answers": [b"some other target 1", b"some other target 2"],
}, {
"idx": np.array([0, 2]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input",
"targets_pretokenized": b"some target 2",
"scores": 0.5,
"answers": [b"some other target 1", b"some other target 2"],
}, {
"idx": np.array([1, 0]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input 2",
"targets_pretokenized": b"some target 1",
"scores": 0.5,
"answers": [b"some other target 3", b"some other target 4"],
}, {
"idx": np.array([1, 1]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input 2",
"targets_pretokenized": b"some target 2",
"scores": 0.1,
"answers": [b"some other target 3", b"some other target 4"],
}]
metric_fn = bb.get_metric_fn(
task_name="test_task",
task_path="test/task/path.json",
bigbench_task_type=bb.BigBenchTaskType.MULTIPLE_CHOICE)
_ = metric_fn(examples, [0.5, 0.7, 0.1, 0.2])
expected_samples = [
collections.OrderedDict([
("input", "some input"),
("target_scores",
collections.OrderedDict([("some target", 0.4),
("some target 2", 0.5)])),
("target", ["some other target 1", "some other target 2"]),
("choice", ["some target", "some target 2"]),
("absolute_log_prob", [0.5, 0.7]),
("normalized_log_prob", [-0.7981388693815918, -0.5981388693815919]),
("log_prob", [-0.7981388693815918, -0.5981388693815919])
]),
collections.OrderedDict([
("input", "some input 2"),
("target_scores",
collections.OrderedDict([("some target 1", 0.5),
("some target 2", 0.1)])),
("target", ["some other target 3", "some other target 4"]),
("choice", ["some target 1", "some target 2"]),
("absolute_log_prob", [0.1, 0.2]),
("normalized_log_prob", [-0.7443966600735709, -0.6443966600735709]),
("log_prob", [-0.7443966600735709, -0.6443966600735709])
])
]
mock_measure.assert_called_once_with(expected_samples,
["metric1", "metric2"])
@mock.patch.object(json_task, "make_nshot_dataset")
def test_get_dataset_fn_few_shot(self, mock_nshot_maker):
self.mock_bigbench_json_task._ds = [{
"input": "some input",
"target": ["some output"]
} for _ in range(100)]
self.mock_bigbench_json_task.few_shot_example_separator = ","
self.mock_bigbench_json_task.task_prefix = "prefix: "
self.mock_bigbench_json_task.rng = None
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
mock_nshot_maker.return_value = [{
"input": "fewshot input",
"target": ["fewshot output"]
} for _ in range(100)]
dataset_fn = bb.get_dataset_fn(
task_name="test_task", task_path="test/task/path.json", num_shots=1)
ds = dataset_fn(split="all", shuffle_files=False)
expected = [{
"inputs": "prefix: fewshot input",
"targets": "fewshot output",
"answers": ["fewshot output"]
} for _ in range(100)]
test_utils.assert_dataset(ds, expected)
def test_get_dataset_fn_multiple_choice(self):
self.mock_bigbench_json_task._ds = self._flatten([[{
"input": "some input 1",
"target_scores": {
"ans1": 0,
"ans2": 1
},
"target": ["ans2"]
}, {
"input": "some input 2",
"target_scores": {
"ans1": 1,
"ans2": 0
},
"target": ["ans1"]
}] for _ in range(100)])
self.mock_bigbench_json_task.task_prefix = "prefix: "
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task",
task_path="test/task/path.json",
bigbench_task_type=bb.BigBenchTaskType.MULTIPLE_CHOICE)
ds = dataset_fn(split="all", shuffle_files=False)
expected = [[{
"inputs": "prefix: some input 1",
"targets": "ans1",
"scores": 0.0,
"idx": [idx, 0],
"answers": ["ans2"]
}, {
"inputs": "prefix: some input 1",
"targets": "ans2",
"scores": 1.0,
"idx": [idx, 1],
"answers": ["ans2"]
}, {
"inputs": "prefix: some input 2",
"targets": "ans1",
"scores": 1.0,
"idx": [idx + 1, 0],
"answers": ["ans1"]
}, {
"inputs": "prefix: some input 2",
"targets": "ans2",
"scores": 0.0,
"idx": [idx + 1, 1],
"answers": ["ans1"]
}] for idx in range(0, 200, 2)]
expected = self._flatten(expected)
test_utils.assert_dataset(ds, expected)
def test_get_dataset_fn_multiple_choice_gen_targets(self):
self.mock_bigbench_json_task._ds = self._flatten([[
{
"input": "some input 1",
"target_scores": {
"ans1": 0,
"ans2": 1,
},
"target": ["some target 1"]
},
{
"input": "some input 2",
"target_scores": {
"ans1": 1,
"ans2": 0,
},
"target": ["some target 2", "some target 3"]
},
] for _ in range(100)])
self.mock_bigbench_json_task.task_prefix = "prefix: "
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task",
task_path="test/task/path.json",
bigbench_task_type=bb.BigBenchTaskType.MULTIPLE_CHOICE)
ds = dataset_fn(split="all", shuffle_files=False)
expected = [[{
"inputs": "prefix: some input 1",
"targets": "ans1",
"scores": 0.0,
"idx": [idx, 0],
"answers": ["some target 1"]
}, {
"inputs": "prefix: some input 1",
"targets": "ans2",
"scores": 1.0,
"idx": [idx, 1],
"answers": ["some target 1"]
}, {
"inputs": "prefix: some input 2",
"targets": "ans1",
"scores": 1.0,
"idx": [idx + 1, 0],
"answers": ["some target 2", "some target 3"]
}, {
"inputs": "prefix: some input 2",
"targets": "ans2",
"scores": 0.0,
"idx": [idx + 1, 1],
"answers": ["some target 2", "some target 3"]
}] for idx in range(0, 200, 2)]
expected = self._flatten(expected)
test_utils.assert_dataset(ds, expected)
def test_get_dataset_fn_scoring(self):
# Setup mock BIG-bench task
self.mock_bigbench_json_task._ds = self._flatten([[{
"input": "some input",
"target": ["some output 1", "some output 2"]
}, {
"input": "some more input",
"target": ["some more output"]
}] for _ in range(100)])
self.mock_bigbench_json_task.task_prefix = "prefix: "
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
dataset_fn = bb.get_dataset_fn(
task_name="test_task",
task_path="test/task/path.json",
bigbench_task_type=bb.BigBenchTaskType.SCORING)
ds = dataset_fn(split="all", shuffle_files=False)
expected = self._flatten([[{
"inputs": "prefix: some input",
"targets": "some output 1",
"idx": np.array([idx, 0])
}, {
"inputs": "prefix: some input",
"targets": "some output 2",
"idx": np.array([idx, 1])
}, {
"inputs": "prefix: some more input",
"targets": "some more output",
"idx": np.array([idx + 1, 0])
}] for idx in range(0, 200, 2)])
test_utils.assert_dataset(ds, expected)
@mock.patch.object(task_metrics, "measure_scoring_metrics")
def test_get_metric_fn_scoring(self, mock_measure):
self.mock_bigbench_json_task.scoring_metrics = ["metric1", "metric2"]
self.mock_bigbench_json_task.task_prefix = ""
self.mock_bb_json_task_api.return_value = self.mock_bigbench_json_task
examples = [{
"idx": np.array([0, 1]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input",
"targets_pretokenized": b"some target",
"scores": 0.4,
}, {
"idx": np.array([0, 2]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input",
"targets_pretokenized": b"some target 2",
"scores": 0.5,
}, {
"idx": np.array([1, 0]),
"inputs": [1, 2, 3],
"targets": [2, 3, 4],
"inputs_pretokenized": b"some input 2",
"targets_pretokenized": b"some target 1",
"scores": 0.5,
}]
metric_fn = bb.get_metric_fn(
task_name="test_task",
task_path="test/task/path.json",
bigbench_task_type=bb.BigBenchTaskType.SCORING)
_ = metric_fn(examples, [0.5, 0.7, 0.1])
expected_samples = [
collections.OrderedDict([("input", "some input"),
("target", ["some target", "some target 2"]),
("log_prob_gen", [0.5, 0.7])]),
collections.OrderedDict([("input", "some input 2"),
("target", ["some target 1"]),
("log_prob_gen", [0.1])])
]
mock_measure.assert_called_once_with(expected_samples,
["metric1", "metric2"])
if __name__ == "__main__":
absltest.main()
| 38.524229 | 80 | 0.614332 |
1851d1b593a6a3bc41bc2d9d9385352696b7f8c1 | 124 | py | Python | mmdet3d/models/fusion_layers/__init__.py | Discover304/MMDetection3D-Explainable | 265be9eba643a253a0d0bd24fb1f74a3f43a0b45 | [
"Apache-2.0"
]
| null | null | null | mmdet3d/models/fusion_layers/__init__.py | Discover304/MMDetection3D-Explainable | 265be9eba643a253a0d0bd24fb1f74a3f43a0b45 | [
"Apache-2.0"
]
| null | null | null | mmdet3d/models/fusion_layers/__init__.py | Discover304/MMDetection3D-Explainable | 265be9eba643a253a0d0bd24fb1f74a3f43a0b45 | [
"Apache-2.0"
]
| null | null | null | # Copyright (c) OpenMMLab. All rights reserved.
from .x_net_fusion_layers import XNetFusion
__all__ = [
'XNetFusion'
]
| 17.714286 | 47 | 0.741935 |
c86c01e73ecc82f48a5b4c144a80bb2abe093de1 | 20,197 | py | Python | Lib/ntpath.py | w0xel/python2.7-mingw32 | a7978642b17cb05b3edd04116db0fe993637ef20 | [
"PSF-2.0"
]
| 3 | 2018-12-25T15:33:48.000Z | 2019-12-04T20:32:32.000Z | Lib/ntpath.py | w0xel/python2.7-mingw32 | a7978642b17cb05b3edd04116db0fe993637ef20 | [
"PSF-2.0"
]
| null | null | null | Lib/ntpath.py | w0xel/python2.7-mingw32 | a7978642b17cb05b3edd04116db0fe993637ef20 | [
"PSF-2.0"
]
| 1 | 2020-11-04T07:54:34.000Z | 2020-11-04T07:54:34.000Z | # Module 'ntpath' -- common operations on WinNT/Win95 pathnames
"""Common pathname manipulations, WindowsNT/95 version.
Instead of importing this module directly, import os and refer to this
module as os.path.
"""
import os
import sys
import stat
import genericpath
import warnings
from genericpath import *
from genericpath import _unicode
__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
"basename","dirname","commonprefix","getsize","getmtime",
"getatime","getctime", "islink","exists","lexists","isdir","isfile",
"ismount","walk","expanduser","expandvars","normpath","abspath",
"splitunc","curdir","pardir","sep","pathsep","defpath","altsep",
"extsep","devnull","realpath","supports_unicode_filenames","relpath"]
# strings representing various path-related bits and pieces
curdir = '.'
pardir = '..'
extsep = '.'
# Generally we prefer forwards slashes for MinGW-w64 Python,
# but should probably defer to the C code and a set of #defines
# with the following precedence and logic:
# DIRSEP_MSYSTEM = If MSYSTEM env. var is set then / otherwise \.
# DIRSEP_ARGV0 = Whichever of / and \ is more prevalent in argv0
# (if equal DIRSEP_FORWARDS or DIRSEP_BACKWARDS)
# DIRSEP_FORWARDS = Always /
# DIRSEP_BACKWARDS = Always \
# .. note, UNC paths are always converted to backslashes.
if sys.platform == "win32" and "MSYSTEM" in os.environ:
sep = '/'
altsep = '\\'
else:
sep = '\\'
altsep = '/'
pathsep = ';'
defpath = '.;C:\\bin'
if 'ce' in sys.builtin_module_names:
defpath = '\\Windows'
elif 'os2' in sys.builtin_module_names:
# OS/2 w/ VACPP
altsep = '/'
devnull = 'nul'
# Normalize the case of a pathname and map slashes to backslashes.
# Other normalizations (such as optimizing '../' away) are not done
# (this is done by normpath).
def normcase(s):
"""Normalize case of pathname.
Makes all characters lowercase and all os.altsep into os.sep."""
return s.replace(os.altsep, os.sep).lower()
# Return whether a path is absolute.
# Trivial in Posix, harder on the Mac or MS-DOS.
# For DOS it is absolute if it starts with a slash or backslash (current
# volume), or if a pathname after the volume letter and colon / UNC resource
# starts with a slash or backslash.
def isabs(s):
"""Test whether a path is absolute"""
s = splitdrive(s)[1]
return s != '' and s[:1] in '/\\'
# Join two (or more) paths.
def join(path, *paths):
"""Join two or more pathname components, inserting sep as needed."""
result_drive, result_path = splitdrive(path)
for p in paths:
p_drive, p_path = splitdrive(p)
if p_path and p_path[0] in '\\/':
# Second path is absolute
if p_drive or not result_drive:
result_drive = p_drive
result_path = p_path
continue
elif p_drive and p_drive != result_drive:
if p_drive.lower() != result_drive.lower():
# Different drives => ignore the first path entirely
result_drive = p_drive
result_path = p_path
continue
# Same drive in different case
result_drive = p_drive
# Second path is relative to the first
if result_path and result_path[-1] not in '\\/':
result_path = result_path + sep
result_path = result_path + p_path
## add separator between UNC and non-absolute path
if (result_path and result_path[0] not in '\\/' and
result_drive and result_drive[-1:] != ':'):
return result_drive + sep + result_path
return result_drive + result_path
# Split a path in a drive specification (a drive letter followed by a
# colon) and the path specification.
# It is always true that drivespec + pathspec == p
def splitdrive(p):
"""Split a pathname into drive/UNC sharepoint and relative path specifiers.
Returns a 2-tuple (drive_or_unc, path); either part may be empty.
If you assign
result = splitdrive(p)
It is always true that:
result[0] + result[1] == p
If the path contained a drive letter, drive_or_unc will contain everything
up to and including the colon. e.g. splitdrive("c:/dir") returns ("c:", "/dir")
If the path contained a UNC path, the drive_or_unc will contain the host name
and share up to but not including the fourth directory separator character.
e.g. splitdrive("//host/computer/dir") returns ("//host/computer", "/dir")
Paths cannot contain both a drive letter and a UNC path.
"""
if len(p) > 1:
normp = p.replace(altsep, sep)
if (normp[0:2] == sep*2) and (normp[2:3] != sep):
# is a UNC path:
# vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
# \\machine\mountpoint\directory\etc\...
# directory ^^^^^^^^^^^^^^^
index = normp.find(sep, 2)
if index == -1:
return '', p
index2 = normp.find(sep, index + 1)
# a UNC path can't have two slashes in a row
# (after the initial two)
if index2 == index + 1:
return '', p
if index2 == -1:
index2 = len(p)
return p[:index2], p[index2:]
if normp[1] == ':':
return p[:2], p[2:]
return '', p
# Parse UNC paths
def splitunc(p):
"""Split a pathname into UNC mount point and relative path specifiers.
Return a 2-tuple (unc, rest); either part may be empty.
If unc is not empty, it has the form '//host/mount' (or similar
using backslashes). unc+rest is always the input path.
Paths containing drive letters never have a UNC part.
"""
if p[1:2] == ':':
return '', p # Drive letter present
firstTwo = p[0:2]
if firstTwo == '//' or firstTwo == '\\\\':
# is a UNC path:
# vvvvvvvvvvvvvvvvvvvv equivalent to drive letter
# \\machine\mountpoint\directories...
# directory ^^^^^^^^^^^^^^^
normp = p.replace('\\', '/')
index = normp.find('/', 2)
if index <= 2:
return '', p
index2 = normp.find('/', index + 1)
# a UNC path can't have two slashes in a row
# (after the initial two)
if index2 == index + 1:
return '', p
if index2 == -1:
index2 = len(p)
return p[:index2], p[index2:]
return '', p
# Split a path in head (everything up to the last '/') and tail (the
# rest). After the trailing '/' is stripped, the invariant
# join(head, tail) == p holds.
# The resulting head won't end in '/' unless it is the root.
def split(p):
"""Split a pathname.
Return tuple (head, tail) where tail is everything after the final slash.
Either part may be empty."""
d, p = splitdrive(p)
# set i to index beyond p's last slash
i = len(p)
while i and p[i-1] not in '/\\':
i = i - 1
head, tail = p[:i], p[i:] # now tail has no slashes
# remove trailing slashes from head, unless it's all slashes
head2 = head
while head2 and head2[-1] in '/\\':
head2 = head2[:-1]
head = head2 or head
return d + head, tail
# Split a path in root and extension.
# The extension is everything starting at the last dot in the last
# pathname component; the root is everything before that.
# It is always true that root + ext == p.
def splitext(p):
return genericpath._splitext(p, sep, altsep, extsep)
splitext.__doc__ = genericpath._splitext.__doc__
# Return the tail (basename) part of a path.
def basename(p):
"""Returns the final component of a pathname"""
return split(p)[1]
# Return the head (dirname) part of a path.
def dirname(p):
"""Returns the directory component of a pathname"""
return split(p)[0]
# Is a path a symbolic link?
# This will always return false on systems where posix.lstat doesn't exist.
def islink(path):
"""Test for symbolic link.
On WindowsNT/95 and OS/2 always returns false
"""
return False
# alias exists to lexists
lexists = exists
# Is a path a mount point? Either a root (with or without drive letter)
# or a UNC path with at most a / or \ after the mount point.
def ismount(path):
"""Test whether a path is a mount point (defined as root of drive)"""
unc, rest = splitunc(path)
if unc:
return rest in ("", "/", "\\")
p = splitdrive(path)[1]
return len(p) == 1 and p[0] in '/\\'
# Directory tree walk.
# For each directory under top (including top itself, but excluding
# '.' and '..'), func(arg, dirname, filenames) is called, where
# dirname is the name of the directory and filenames is the list
# of files (and subdirectories etc.) in the directory.
# The func may modify the filenames list, to implement a filter,
# or to impose a different order of visiting.
def walk(top, func, arg):
"""Directory tree walk with callback function.
For each directory in the directory tree rooted at top (including top
itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
dirname is the name of the directory, and fnames a list of the names of
the files and subdirectories in dirname (excluding '.' and '..'). func
may modify the fnames list in-place (e.g. via del or slice assignment),
and walk will only recurse into the subdirectories whose names remain in
fnames; this can be used to implement a filter, or to impose a specific
order of visiting. No semantics are defined for, or required of, arg,
beyond that arg is always passed to func. It can be used, e.g., to pass
a filename pattern, or a mutable object designed to accumulate
statistics. Passing None for arg is common."""
warnings.warnpy3k("In 3.x, os.path.walk is removed in favor of os.walk.",
stacklevel=2)
try:
names = os.listdir(top)
except os.error:
return
func(arg, top, names)
for name in names:
name = join(top, name)
if isdir(name):
walk(name, func, arg)
# Expand paths beginning with '~' or '~user'.
# '~' means $HOME; '~user' means that user's home directory.
# If the path doesn't begin with '~', or if the user or $HOME is unknown,
# the path is returned unchanged (leaving error reporting to whatever
# function is called with the expanded path as argument).
# See also module 'glob' for expansion of *, ? and [...] in pathnames.
# (A function should also be defined to do full *sh-style environment
# variable expansion.)
def expanduser(path):
"""Expand ~ and ~user constructs.
If user or $HOME is unknown, do nothing."""
if path[:1] != '~':
return path
i, n = 1, len(path)
while i < n and path[i] not in '/\\':
i = i + 1
if 'HOME' in os.environ:
userhome = os.environ['HOME']
elif 'USERPROFILE' in os.environ:
userhome = os.environ['USERPROFILE']
elif not 'HOMEPATH' in os.environ:
return path
else:
try:
drive = os.environ['HOMEDRIVE']
except KeyError:
drive = ''
userhome = join(drive, os.environ['HOMEPATH'])
if i != 1: #~user
userhome = join(dirname(userhome), path[1:i])
return userhome + path[i:]
# Expand paths containing shell variable substitutions.
# The following rules apply:
# - no expansion within single quotes
# - '$$' is translated into '$'
# - '%%' is translated into '%' if '%%' are not seen in %var1%%var2%
# - ${varname} is accepted.
# - $varname is accepted.
# - %varname% is accepted.
# - varnames can be made out of letters, digits and the characters '_-'
# (though is not verified in the ${varname} and %varname% cases)
# XXX With COMMAND.COM you can use any characters in a variable name,
# XXX except '^|<>='.
def expandvars(path):
"""Expand shell variables of the forms $var, ${var} and %var%.
Unknown variables are left unchanged."""
if '$' not in path and '%' not in path:
return path
import string
varchars = string.ascii_letters + string.digits + '_-'
if isinstance(path, _unicode):
encoding = sys.getfilesystemencoding()
def getenv(var):
return os.environ[var.encode(encoding)].decode(encoding)
else:
def getenv(var):
return os.environ[var]
res = ''
index = 0
pathlen = len(path)
while index < pathlen:
c = path[index]
if c == '\'': # no expansion within single quotes
path = path[index + 1:]
pathlen = len(path)
try:
index = path.index('\'')
res = res + '\'' + path[:index + 1]
except ValueError:
res = res + c + path
index = pathlen - 1
elif c == '%': # variable or '%'
if path[index + 1:index + 2] == '%':
res = res + c
index = index + 1
else:
path = path[index+1:]
pathlen = len(path)
try:
index = path.index('%')
except ValueError:
res = res + '%' + path
index = pathlen - 1
else:
var = path[:index]
try:
res = res + getenv(var)
except KeyError:
res = res + '%' + var + '%'
elif c == '$': # variable or '$$'
if path[index + 1:index + 2] == '$':
res = res + c
index = index + 1
elif path[index + 1:index + 2] == '{':
path = path[index+2:]
pathlen = len(path)
try:
index = path.index('}')
var = path[:index]
try:
res = res + getenv(var)
except KeyError:
res = res + '${' + var + '}'
except ValueError:
res = res + '${' + path
index = pathlen - 1
else:
var = ''
index = index + 1
c = path[index:index + 1]
while c != '' and c in varchars:
var = var + c
index = index + 1
c = path[index:index + 1]
try:
res = res + getenv(var)
except KeyError:
res = res + '$' + var
if c != '':
index = index - 1
else:
res = res + c
index = index + 1
return res
# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A\B.
# Previously, this function also truncated pathnames to 8+3 format,
# but as this module is called "ntpath", that's obviously wrong!
def normpath(path):
"""Normalize path, eliminating double slashes, etc."""
# Preserve unicode (if path is unicode)
backslash, dot = (u'\\', u'.') if isinstance(path, _unicode) else ('\\', '.')
isUNC = path.startswith('\\\\')
this_sep = sep
other_sep = altsep
if isUNC:
this_sep = backslash
other_sep = '/'
if path.startswith(('\\\\.\\', '\\\\?\\')):
# in the case of paths with these prefixes:
# \\.\ -> device names
# \\?\ -> literal paths
# do not do any normalization, but return the path unchanged
return path
path = path.replace(other_sep, this_sep)
prefix, path = splitdrive(path)
# We need to be careful here. If the prefix is empty, and the path starts
# with a backslash, it could either be an absolute path on the current
# drive (\dir1\dir2\file) or a UNC filename (\\server\mount\dir1\file). It
# is therefore imperative NOT to collapse multiple backslashes blindly in
# that case.
# The code below preserves multiple backslashes when there is no drive
# letter. This means that the invalid filename \\\a\b is preserved
# unchanged, where a\\\b is normalised to a\b. It's not clear that there
# is any better behaviour for such edge cases.
if prefix == '':
# No drive letter - preserve initial backslashes
while path[:1] == this_sep:
prefix = prefix + this_sep
path = path[1:]
else:
# We have a drive letter - collapse initial backslashes
if path.startswith(sep):
prefix = prefix + this_sep
path = path.lstrip(this_sep)
comps = path.split(this_sep)
i = 0
while i < len(comps):
if comps[i] in ('.', ''):
del comps[i]
elif comps[i] == '..':
if i > 0 and comps[i-1] != '..':
del comps[i-1:i+1]
i -= 1
elif i == 0 and prefix.endswith(this_sep):
del comps[i]
else:
i += 1
else:
i += 1
# If the path is now empty, substitute '.'
if not prefix and not comps:
comps.append(dot)
return prefix + this_sep.join(comps)
# Return an absolute path.
try:
from nt import _getfullpathname
except ImportError: # not running on Windows - mock up something sensible
def abspath(path):
"""Return the absolute version of a path."""
if not isabs(path):
if isinstance(path, _unicode):
cwd = os.getcwdu()
else:
cwd = os.getcwd()
path = join(cwd, path)
return normpath(path)
else: # use native Windows method on Windows
def abspath(path):
"""Return the absolute version of a path."""
if path: # Empty path must return current working directory.
try:
path = _getfullpathname(path)
except WindowsError:
pass # Bad path - return unchanged.
elif isinstance(path, _unicode):
path = os.getcwdu()
else:
path = os.getcwd()
return normpath(path)
# realpath is a no-op on systems without islink support
realpath = abspath
# Win9x family and earlier have no Unicode filename support.
supports_unicode_filenames = (hasattr(sys, "getwindowsversion") and
sys.getwindowsversion()[3] >= 2)
def _abspath_split(path):
abs = abspath(normpath(path))
prefix, rest = splitunc(abs)
is_unc = bool(prefix)
if not is_unc:
prefix, rest = splitdrive(abs)
return is_unc, prefix, [x for x in rest.split(sep) if x]
def relpath(path, start=curdir):
"""Return a relative version of a path"""
if not path:
raise ValueError("no path specified")
start_is_unc, start_prefix, start_list = _abspath_split(start)
path_is_unc, path_prefix, path_list = _abspath_split(path)
if path_is_unc ^ start_is_unc:
raise ValueError("Cannot mix UNC and non-UNC paths (%s and %s)"
% (path, start))
if path_prefix.lower() != start_prefix.lower():
if path_is_unc:
raise ValueError("path is on UNC root %s, start on UNC root %s"
% (path_prefix, start_prefix))
else:
raise ValueError("path is on drive %s, start on drive %s"
% (path_prefix, start_prefix))
# Work out how much of the filepath is shared by start and path.
i = 0
for e1, e2 in zip(start_list, path_list):
if e1.lower() != e2.lower():
break
i += 1
rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
if not rel_list:
return curdir
return join(*rel_list)
try:
# The genericpath.isdir implementation uses os.stat and checks the mode
# attribute to tell whether or not the path is a directory.
# This is overkill on Windows - just pass the path to GetFileAttributes
# and check the attribute from there.
from nt import _isdir as isdir
except ImportError:
# Use genericpath.isdir as imported above.
pass
| 35.433333 | 84 | 0.580779 |
643dce6c91ba9b91d2b4aaf389bcd9f480d3d2a3 | 2,758 | py | Python | tests/test_cli.py | samwellzuk/py-lambda-packer | 380d0b748d5e83dbdd58c87de532a26cccbb8ec8 | [
"MIT"
]
| null | null | null | tests/test_cli.py | samwellzuk/py-lambda-packer | 380d0b748d5e83dbdd58c87de532a26cccbb8ec8 | [
"MIT"
]
| null | null | null | tests/test_cli.py | samwellzuk/py-lambda-packer | 380d0b748d5e83dbdd58c87de532a26cccbb8ec8 | [
"MIT"
]
| null | null | null | from __future__ import (absolute_import, division, print_function,
unicode_literals)
import pytest
from plpacker.cli import parse_args
class TestParseArgs(object):
def test_defaults(self, source_fs):
# pylint: disable=unused-argument, no-self-use
args = vars(parse_args([]))
assert args['archive_dir'] is None
assert args['config_file'] is None
assert args['excludes'] is None
assert args['followlinks'] is None
assert args['generate_config'] is False
assert args['includes'] is None
assert args['keep_archive'] is None
assert args['keep_virtualenv'] is None
assert args['output'] is None
assert args['packages'] is None
assert args['python'] is None
assert args['requirements'] is None
assert args['virtualenv_dir'] is None
cli_options = (
(['--config-file', 'config_file_path'],
'config_file',
'config_file_path'),
(['--include', 'includeA'],
'includes',
['includeA']),
(['--exclude', 'exclude2', '--exclude', 'exclude1'],
'excludes',
['exclude2', 'exclude1']),
(['--followlinks'],
'followlinks',
True),
(['--virtualenv-dir', 'targer_virtualenv_dir'],
'virtualenv_dir',
'targer_virtualenv_dir'),
(['--keep-virtualenv'],
'keep_virtualenv',
True),
(['--python', 'some_python_ver'],
'python',
'some_python_ver'),
(['--requirement', 'req1',
'--requirement', 'req2',
'--requirement', 'req3'],
'requirements',
['req1', 'req2', 'req3']),
(['-r', 'single_req'],
'requirements',
['single_req']),
(['--package', 'package1', '--package', 'package2'],
'packages',
['package1', 'package2']),
(['--package', 'pip-package'],
'packages',
['pip-package']),
(['-p', 'another_pip_package'],
'packages',
['another_pip_package']),
(['--output', 'some_other_zip'],
'output',
'some_other_zip'),
(['-o', 'some_output_file'],
'output',
'some_output_file'),
(['--archive-dir', 'some_archive_dir'],
'archive_dir',
'some_archive_dir'),
(['--keep-archive'],
'keep_archive',
True),
(['--generate-config'],
'generate_config',
True),
)
@pytest.mark.parametrize("argv,key,expected", cli_options)
def test_foohoo(self, argv, key, expected):
# pylint: disable=no-self-use
result = vars(parse_args(argv))
assert result[key] == expected
| 31.340909 | 66 | 0.531907 |
0cdffd28a71cdc789ba10aa76d4054852271f582 | 2,450 | py | Python | hugin/hugin/minlf.py | MetaphorExtractionTools/metaphor-search | ca0ba6cda8d83eb9274eb2b9d7977df4a5374b18 | [
"MIT"
]
| 2 | 2018-05-25T01:47:50.000Z | 2021-11-26T19:03:07.000Z | hugin/hugin/minlf.py | MetaphorExtractionTools/metaphor-search | ca0ba6cda8d83eb9274eb2b9d7977df4a5374b18 | [
"MIT"
]
| null | null | null | hugin/hugin/minlf.py | MetaphorExtractionTools/metaphor-search | ca0ba6cda8d83eb9274eb2b9d7977df4a5374b18 | [
"MIT"
]
| 1 | 2020-02-06T16:04:07.000Z | 2020-02-06T16:04:07.000Z | #!/usr/bin/env python
# coding: utf-8
# Copyright (C) USC Information Sciences Institute
# Author: Vladimir M. Zaytsev <[email protected]>
# URL: <http://nlg.isi.edu/>
# For more information, see README.md
# For license information, see LICENSE
import re
import logging
class MinBoxerLFSParser(object):
LF_COMMENT_PRT = re.compile("%+\s*(.+)")
LF_TERM_PRT = re.compile("((\[.*?\]\:)([^ .]+?)\-[a-z]+(\([,a-z0-9]+?\))?)")
LF_EMPTY_LINE = re.compile("^\s*$")
LF_TERM_LINE = re.compile("^\d+\s+(.+)$")
def __init__(self, i_file):
self.i_file = i_file
def __iter__(self):
raw_text = ""
self.i_file.next()
self.i_file.next()
terms = None
for line in self.i_file:
if line.startswith("%%% "):
terms = []
raw_text_match = self.LF_COMMENT_PRT.findall(line)
if len(raw_text_match) == 1:
raw_text = raw_text_match[0]
else:
raw_text = ""
logging.warn("Got strange LF comment line: %s" % line)
elif line.startswith("id(") or self.LF_EMPTY_LINE.match(line):
continue
elif self.LF_TERM_LINE.match(line):
_, form, pos, lemma, biotag = line.split()
terms.append(lemma.lower())
else:
lf_line = line
yield raw_text, lf_line, terms
class MinLFSParser(object):
LF_COMMENT_PRT = re.compile("%+\s*(.+)")
LF_TERM_PRT = re.compile("((\[.+?\]\:)([^ .]+?)\-[a-z]+(\([,a-z0-9]+?\))?)")
LF_EMPTY_LINE = re.compile("^\s*$")
def __init__(self, i_file):
self.i_file = i_file
def __iter__(self):
raw_text = ""
for line in self.i_file:
if line.startswith("%"):
raw_text_match = self.LF_COMMENT_PRT.findall(line)
if len(raw_text_match) == 1:
raw_text = raw_text_match[0]
else:
raw_text = ""
logging.warn("Got strange LF comment line: %s" % line)
elif line.startswith("id(") or self.LF_EMPTY_LINE.match(line):
continue
else:
terms_match = self.LF_TERM_PRT.findall(line)
terms = [m[2] for m in terms_match] if terms_match is not None else []
lf_line = line
yield raw_text, lf_line, terms | 35 | 86 | 0.522857 |
8705954edd0c17a163ce67d6ec2eca8f04129afd | 2,757 | py | Python | google/cloud/tpu/v1/tpu-v1-py/google/cloud/tpu/__init__.py | googleapis/googleapis-gen | d84824c78563d59b0e58d5664bfaa430e9ad7e7a | [
"Apache-2.0"
]
| 7 | 2021-02-21T10:39:41.000Z | 2021-12-07T07:31:28.000Z | google/cloud/tpu/v1/tpu-v1-py/google/cloud/tpu/__init__.py | googleapis/googleapis-gen | d84824c78563d59b0e58d5664bfaa430e9ad7e7a | [
"Apache-2.0"
]
| 6 | 2021-02-02T23:46:11.000Z | 2021-11-15T01:46:02.000Z | google/cloud/tpu/v1/tpu-v1-py/google/cloud/tpu/__init__.py | googleapis/googleapis-gen | d84824c78563d59b0e58d5664bfaa430e9ad7e7a | [
"Apache-2.0"
]
| 4 | 2021-01-28T23:25:45.000Z | 2021-08-30T01:55:16.000Z | # -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from google.cloud.tpu_v1.services.tpu.client import TpuClient
from google.cloud.tpu_v1.services.tpu.async_client import TpuAsyncClient
from google.cloud.tpu_v1.types.cloud_tpu import AcceleratorType
from google.cloud.tpu_v1.types.cloud_tpu import CreateNodeRequest
from google.cloud.tpu_v1.types.cloud_tpu import DeleteNodeRequest
from google.cloud.tpu_v1.types.cloud_tpu import GetAcceleratorTypeRequest
from google.cloud.tpu_v1.types.cloud_tpu import GetNodeRequest
from google.cloud.tpu_v1.types.cloud_tpu import GetTensorFlowVersionRequest
from google.cloud.tpu_v1.types.cloud_tpu import ListAcceleratorTypesRequest
from google.cloud.tpu_v1.types.cloud_tpu import ListAcceleratorTypesResponse
from google.cloud.tpu_v1.types.cloud_tpu import ListNodesRequest
from google.cloud.tpu_v1.types.cloud_tpu import ListNodesResponse
from google.cloud.tpu_v1.types.cloud_tpu import ListTensorFlowVersionsRequest
from google.cloud.tpu_v1.types.cloud_tpu import ListTensorFlowVersionsResponse
from google.cloud.tpu_v1.types.cloud_tpu import NetworkEndpoint
from google.cloud.tpu_v1.types.cloud_tpu import Node
from google.cloud.tpu_v1.types.cloud_tpu import OperationMetadata
from google.cloud.tpu_v1.types.cloud_tpu import ReimageNodeRequest
from google.cloud.tpu_v1.types.cloud_tpu import SchedulingConfig
from google.cloud.tpu_v1.types.cloud_tpu import StartNodeRequest
from google.cloud.tpu_v1.types.cloud_tpu import StopNodeRequest
from google.cloud.tpu_v1.types.cloud_tpu import Symptom
from google.cloud.tpu_v1.types.cloud_tpu import TensorFlowVersion
__all__ = ('TpuClient',
'TpuAsyncClient',
'AcceleratorType',
'CreateNodeRequest',
'DeleteNodeRequest',
'GetAcceleratorTypeRequest',
'GetNodeRequest',
'GetTensorFlowVersionRequest',
'ListAcceleratorTypesRequest',
'ListAcceleratorTypesResponse',
'ListNodesRequest',
'ListNodesResponse',
'ListTensorFlowVersionsRequest',
'ListTensorFlowVersionsResponse',
'NetworkEndpoint',
'Node',
'OperationMetadata',
'ReimageNodeRequest',
'SchedulingConfig',
'StartNodeRequest',
'StopNodeRequest',
'Symptom',
'TensorFlowVersion',
)
| 41.772727 | 78 | 0.80885 |
f82cea7121c043fbc857651858a2025fdc679994 | 7,718 | py | Python | google/cloud/compute_v1/services/node_types/transports/base.py | Ctfbuster/python-compute | 7a9e8324e08c46a93050908760b2b5aca054a863 | [
"Apache-2.0"
]
| 19 | 2021-02-10T21:17:20.000Z | 2022-02-20T03:16:36.000Z | google/cloud/compute_v1/services/node_types/transports/base.py | Ctfbuster/python-compute | 7a9e8324e08c46a93050908760b2b5aca054a863 | [
"Apache-2.0"
]
| 121 | 2021-01-08T23:46:58.000Z | 2022-03-26T04:34:36.000Z | google/cloud/compute_v1/services/node_types/transports/base.py | Ctfbuster/python-compute | 7a9e8324e08c46a93050908760b2b5aca054a863 | [
"Apache-2.0"
]
| 20 | 2021-01-08T23:14:16.000Z | 2022-02-25T01:27:20.000Z | # -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import abc
from typing import Awaitable, Callable, Dict, Optional, Sequence, Union
import packaging.version
import pkg_resources
from requests import __version__ as requests_version
import google.auth # type: ignore
import google.api_core # type: ignore
from google.api_core import exceptions as core_exceptions # type: ignore
from google.api_core import gapic_v1 # type: ignore
from google.api_core import retry as retries # type: ignore
from google.auth import credentials as ga_credentials # type: ignore
from google.oauth2 import service_account # type: ignore
from google.cloud.compute_v1.types import compute
try:
DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
gapic_version=pkg_resources.get_distribution("google-cloud-compute",).version,
grpc_version=None,
rest_version=requests_version,
)
except pkg_resources.DistributionNotFound:
DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo()
try:
# google.auth.__version__ was added in 1.26.0
_GOOGLE_AUTH_VERSION = google.auth.__version__
except AttributeError:
try: # try pkg_resources if it is available
_GOOGLE_AUTH_VERSION = pkg_resources.get_distribution("google-auth").version
except pkg_resources.DistributionNotFound: # pragma: NO COVER
_GOOGLE_AUTH_VERSION = None
class NodeTypesTransport(abc.ABC):
"""Abstract transport class for NodeTypes."""
AUTH_SCOPES = (
"https://www.googleapis.com/auth/compute.readonly",
"https://www.googleapis.com/auth/compute",
"https://www.googleapis.com/auth/cloud-platform",
)
DEFAULT_HOST: str = "compute.googleapis.com"
def __init__(
self,
*,
host: str = DEFAULT_HOST,
credentials: ga_credentials.Credentials = None,
credentials_file: Optional[str] = None,
scopes: Optional[Sequence[str]] = None,
quota_project_id: Optional[str] = None,
client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
always_use_jwt_access: Optional[bool] = False,
**kwargs,
) -> None:
"""Instantiate the transport.
Args:
host (Optional[str]):
The hostname to connect to.
credentials (Optional[google.auth.credentials.Credentials]): The
authorization credentials to attach to requests. These
credentials identify the application to the service; if none
are specified, the client will attempt to ascertain the
credentials from the environment.
credentials_file (Optional[str]): A file with credentials that can
be loaded with :func:`google.auth.load_credentials_from_file`.
This argument is mutually exclusive with credentials.
scopes (Optional[Sequence[str]]): A list of scopes.
quota_project_id (Optional[str]): An optional project to use for billing
and quota.
client_info (google.api_core.gapic_v1.client_info.ClientInfo):
The client info used to send a user-agent string along with
API requests. If ``None``, then default info will be used.
Generally, you only need to set this if you're developing
your own client library.
always_use_jwt_access (Optional[bool]): Whether self signed JWT should
be used for service account credentials.
"""
# Save the hostname. Default to port 443 (HTTPS) if none is specified.
if ":" not in host:
host += ":443"
self._host = host
scopes_kwargs = self._get_scopes_kwargs(self._host, scopes)
# Save the scopes.
self._scopes = scopes
# If no credentials are provided, then determine the appropriate
# defaults.
if credentials and credentials_file:
raise core_exceptions.DuplicateCredentialArgs(
"'credentials_file' and 'credentials' are mutually exclusive"
)
if credentials_file is not None:
credentials, _ = google.auth.load_credentials_from_file(
credentials_file, **scopes_kwargs, quota_project_id=quota_project_id
)
elif credentials is None:
credentials, _ = google.auth.default(
**scopes_kwargs, quota_project_id=quota_project_id
)
# If the credentials is service account credentials, then always try to use self signed JWT.
if (
always_use_jwt_access
and isinstance(credentials, service_account.Credentials)
and hasattr(service_account.Credentials, "with_always_use_jwt_access")
):
credentials = credentials.with_always_use_jwt_access(True)
# Save the credentials.
self._credentials = credentials
# TODO(busunkim): This method is in the base transport
# to avoid duplicating code across the transport classes. These functions
# should be deleted once the minimum required versions of google-auth is increased.
# TODO: Remove this function once google-auth >= 1.25.0 is required
@classmethod
def _get_scopes_kwargs(
cls, host: str, scopes: Optional[Sequence[str]]
) -> Dict[str, Optional[Sequence[str]]]:
"""Returns scopes kwargs to pass to google-auth methods depending on the google-auth version"""
scopes_kwargs = {}
if _GOOGLE_AUTH_VERSION and (
packaging.version.parse(_GOOGLE_AUTH_VERSION)
>= packaging.version.parse("1.25.0")
):
scopes_kwargs = {"scopes": scopes, "default_scopes": cls.AUTH_SCOPES}
else:
scopes_kwargs = {"scopes": scopes or cls.AUTH_SCOPES}
return scopes_kwargs
def _prep_wrapped_messages(self, client_info):
# Precompute the wrapped methods.
self._wrapped_methods = {
self.aggregated_list: gapic_v1.method.wrap_method(
self.aggregated_list, default_timeout=None, client_info=client_info,
),
self.get: gapic_v1.method.wrap_method(
self.get, default_timeout=None, client_info=client_info,
),
self.list: gapic_v1.method.wrap_method(
self.list, default_timeout=None, client_info=client_info,
),
}
@property
def aggregated_list(
self,
) -> Callable[
[compute.AggregatedListNodeTypesRequest],
Union[
compute.NodeTypeAggregatedList, Awaitable[compute.NodeTypeAggregatedList]
],
]:
raise NotImplementedError()
@property
def get(
self,
) -> Callable[
[compute.GetNodeTypeRequest],
Union[compute.NodeType, Awaitable[compute.NodeType]],
]:
raise NotImplementedError()
@property
def list(
self,
) -> Callable[
[compute.ListNodeTypesRequest],
Union[compute.NodeTypeList, Awaitable[compute.NodeTypeList]],
]:
raise NotImplementedError()
__all__ = ("NodeTypesTransport",)
| 37.833333 | 103 | 0.663125 |
7d2bdc2f07997479c78032972837c72a46be4c2f | 5,617 | py | Python | doc/examples/kfold_xval.py | JohnGriffiths/dipy | 5fb38e9b77547cdaf5eb140730444535733ae01d | [
"BSD-3-Clause"
]
| 2 | 2018-07-25T14:04:20.000Z | 2021-02-10T07:10:10.000Z | doc/examples/kfold_xval.py | JohnGriffiths/dipy | 5fb38e9b77547cdaf5eb140730444535733ae01d | [
"BSD-3-Clause"
]
| null | null | null | doc/examples/kfold_xval.py | JohnGriffiths/dipy | 5fb38e9b77547cdaf5eb140730444535733ae01d | [
"BSD-3-Clause"
]
| 2 | 2018-07-24T21:20:54.000Z | 2018-08-27T04:08:24.000Z | """
============================================
K-fold cross-validation for model comparison
============================================
Different models of diffusion MRI can be compared based on their accuracy in
fitting the diffusion signal. Here, we demonstrate this by comparing two
models: the diffusion tensor model (DTI) and constrained spherical
deconvolution (CSD). These models differ from each other substantially. DTI
approximates the diffusion pattern as a 3D Gaussian distribution, and has only
6 free parameters. CSD, on the other hand, fits many more parameters. The
models aare also not nested, so they cannot be compared using the
log-likelihood ratio.
A general way to perform model comparison is cross-validation [Hastie2008]_. In
this method, a model is fit to some of the data (a *learning set*) and the
model is then used to predict a held-out set (a *testing set*). The model
predictions can then be compared to estimate prediction error on the held out
set. This method has been used for comparison of models such as DTI and CSD
[Rokem2014]_, and has the advantage that it the comparison is imprevious to
differences in the number of parameters in the model, and it can be used to
compare models that are not nested.
In `dipy`, we include an implementation of k-fold cross-validation. In this
method, the data is divided into $k$ different segments. In each iteration
$\frac{1}{k}th$ of the data is held out and the model is fit to the other
$\frac{k-1}{k}$ parts of the data. A prediction of the held out data is done
and recorded. At the end of $k$ iterations a prediction of all of the data will
have been conducted, and this can be compared directly to all of the data.
First, we import that modules needed for this example. In particular, the
:mod:`reconst.cross_validation` module implements k-fold cross-validation
"""
import numpy as np
np.random.seed(2014)
import matplotlib.pyplot as plt
import dipy.data as dpd
import dipy.reconst.cross_validation as xval
import dipy.reconst.dti as dti
import dipy.reconst.csdeconv as csd
import scipy.stats as stats
"""
We fetch some data and select a couple of voxels to perform comparisons on. One
lies in the corpus callosum (cc), while the other is in the centrum semiovale
(cso), a part of the brain known to contain multiple crossing white matter
fiber populations.
"""
dpd.fetch_stanford_hardi()
img, gtab = dpd.read_stanford_hardi()
data = img.get_data()
cc_vox = data[40, 70, 38]
cso_vox = data[30, 76, 38]
"""
We initialize each kind of model:
"""
dti_model = dti.TensorModel(gtab)
response, ratio = csd.auto_response(gtab, data, roi_radius=10, fa_thr=0.7)
csd_model = csd.ConstrainedSphericalDeconvModel(gtab, response)
"""
Next, we perform cross-validation for each kind of model, comparing model
predictions to the diffusion MRI data in each one of these voxels.
Note that we use 2-fold cross-validation, which means that in each iteration,
the model will be fit to half of the data, and used to predict the other half.
"""
dti_cc = xval.kfold_xval(dti_model, cc_vox, 2)
csd_cc = xval.kfold_xval(csd_model, cc_vox, 2, response)
dti_cso = xval.kfold_xval(dti_model, cso_vox, 2)
csd_cso = xval.kfold_xval(csd_model, cso_vox, 2, response)
"""
We plot a scatter plot of the data with the model predictions in each of these
voxels, focusing only on the diffusion-weighted measurements (each point
corresponds to a different gradient direction). The two models are compared in
each sub-plot (blue=DTI, red=CSD).
"""
fig, ax = plt.subplots(1,2)
fig.set_size_inches([12,6])
ax[0].plot(cc_vox[~gtab.b0s_mask], dti_cc[~gtab.b0s_mask], 'o', color='b')
ax[0].plot(cc_vox[~gtab.b0s_mask], csd_cc[~gtab.b0s_mask], 'o', color='r')
ax[1].plot(cso_vox[~gtab.b0s_mask], dti_cso[~gtab.b0s_mask], 'o', color='b', label='DTI')
ax[1].plot(cso_vox[~gtab.b0s_mask], csd_cso[~gtab.b0s_mask], 'o', color='r', label='CSD')
plt.legend(loc='upper left')
for this_ax in ax:
this_ax.set_xlabel('Data (relative to S0)')
this_ax.set_ylabel('Model prediction (relative to S0)')
fig.savefig("model_predictions.png")
"""
.. figure:: model_predictions.png
:align: center
**Model predictions**.
"""
"""
We can also quantify the goodness of fit of the models by calculating an
R-squared score:
"""
cc_dti_r2=stats.pearsonr(cc_vox[~gtab.b0s_mask], dti_cc[~gtab.b0s_mask])[0]**2
cc_csd_r2=stats.pearsonr(cc_vox[~gtab.b0s_mask], csd_cc[~gtab.b0s_mask])[0]**2
cso_dti_r2=stats.pearsonr(cso_vox[~gtab.b0s_mask], dti_cso[~gtab.b0s_mask])[0]**2
cso_csd_r2=stats.pearsonr(cso_vox[~gtab.b0s_mask], csd_cso[~gtab.b0s_mask])[0]**2
print("Corpus callosum\n"
"DTI R2 : %s\n"
"CSD R2 : %s\n"
"\n"
"Centrum Semiovale\n"
"DTI R2 : %s\n"
"CSD R2 : %s\n" % (cc_dti_r2, cc_csd_r2, cso_dti_r2, cso_csd_r2))
"""
This should look something like this::
Corpus callosum
DTI R2 : 0.782881752597
CSD R2 : 0.805764364116
Centrum Semiovale
DTI R2 : 0.431921832012
CSD R2 : 0.604806420501
As you can see, DTI is a pretty good model for describing the signal in the CC,
while CSD is much better in describing the signal in regions of multiple
crossing fibers.
References
----------
.. [Hastie2008] Hastie, T., Tibshirani, R., Friedman, J. (2008). The Elements
of Statistical Learning: Data Mining, Inference and
Prediction. Springer-Verlag, Berlin
.. [Rokem2014] Rokem, A., Chan, K.L. Yeatman, J.D., Pestilli, F., Mezer, A.,
Wandell, B.A., 2014. Evaluating the accuracy of diffusion models at multiple
b-values with cross-validation. ISMRM 2014.
.. include:: ../links_names.inc
"""
| 31.734463 | 89 | 0.729927 |
879def8bcdffacdb417aa75fa825f10199e879e7 | 58,286 | py | Python | moto/elbv2/responses.py | STRRL/mono-ext | dbaa6143508eeacd24d46e897b1d764af9ac107e | [
"Apache-2.0"
]
| null | null | null | moto/elbv2/responses.py | STRRL/mono-ext | dbaa6143508eeacd24d46e897b1d764af9ac107e | [
"Apache-2.0"
]
| null | null | null | moto/elbv2/responses.py | STRRL/mono-ext | dbaa6143508eeacd24d46e897b1d764af9ac107e | [
"Apache-2.0"
]
| null | null | null | from __future__ import unicode_literals
from moto.core.exceptions import RESTError
from moto.core.utils import amzn_request_id
from moto.core.responses import BaseResponse
from .models import elbv2_backends
from .exceptions import DuplicateTagKeysError
from .exceptions import LoadBalancerNotFoundError
from .exceptions import TargetGroupNotFoundError
SSL_POLICIES = [
{
"name": "ELBSecurityPolicy-2016-08",
"ssl_protocols": ["TLSv1", "TLSv1.1", "TLSv1.2"],
"ciphers": [
{"name": "ECDHE-ECDSA-AES128-GCM-SHA256", "priority": 1},
{"name": "ECDHE-RSA-AES128-GCM-SHA256", "priority": 2},
{"name": "ECDHE-ECDSA-AES128-SHA256", "priority": 3},
{"name": "ECDHE-RSA-AES128-SHA256", "priority": 4},
{"name": "ECDHE-ECDSA-AES128-SHA", "priority": 5},
{"name": "ECDHE-RSA-AES128-SHA", "priority": 6},
{"name": "ECDHE-ECDSA-AES256-GCM-SHA384", "priority": 7},
{"name": "ECDHE-RSA-AES256-GCM-SHA384", "priority": 8},
{"name": "ECDHE-ECDSA-AES256-SHA384", "priority": 9},
{"name": "ECDHE-RSA-AES256-SHA384", "priority": 10},
{"name": "ECDHE-RSA-AES256-SHA", "priority": 11},
{"name": "ECDHE-ECDSA-AES256-SHA", "priority": 12},
{"name": "AES128-GCM-SHA256", "priority": 13},
{"name": "AES128-SHA256", "priority": 14},
{"name": "AES128-SHA", "priority": 15},
{"name": "AES256-GCM-SHA384", "priority": 16},
{"name": "AES256-SHA256", "priority": 17},
{"name": "AES256-SHA", "priority": 18},
],
},
{
"name": "ELBSecurityPolicy-TLS-1-2-2017-01",
"ssl_protocols": ["TLSv1.2"],
"ciphers": [
{"name": "ECDHE-ECDSA-AES128-GCM-SHA256", "priority": 1},
{"name": "ECDHE-RSA-AES128-GCM-SHA256", "priority": 2},
{"name": "ECDHE-ECDSA-AES128-SHA256", "priority": 3},
{"name": "ECDHE-RSA-AES128-SHA256", "priority": 4},
{"name": "ECDHE-ECDSA-AES256-GCM-SHA384", "priority": 5},
{"name": "ECDHE-RSA-AES256-GCM-SHA384", "priority": 6},
{"name": "ECDHE-ECDSA-AES256-SHA384", "priority": 7},
{"name": "ECDHE-RSA-AES256-SHA384", "priority": 8},
{"name": "AES128-GCM-SHA256", "priority": 9},
{"name": "AES128-SHA256", "priority": 10},
{"name": "AES256-GCM-SHA384", "priority": 11},
{"name": "AES256-SHA256", "priority": 12},
],
},
{
"name": "ELBSecurityPolicy-TLS-1-1-2017-01",
"ssl_protocols": ["TLSv1.1", "TLSv1.2"],
"ciphers": [
{"name": "ECDHE-ECDSA-AES128-GCM-SHA256", "priority": 1},
{"name": "ECDHE-RSA-AES128-GCM-SHA256", "priority": 2},
{"name": "ECDHE-ECDSA-AES128-SHA256", "priority": 3},
{"name": "ECDHE-RSA-AES128-SHA256", "priority": 4},
{"name": "ECDHE-ECDSA-AES128-SHA", "priority": 5},
{"name": "ECDHE-RSA-AES128-SHA", "priority": 6},
{"name": "ECDHE-ECDSA-AES256-GCM-SHA384", "priority": 7},
{"name": "ECDHE-RSA-AES256-GCM-SHA384", "priority": 8},
{"name": "ECDHE-ECDSA-AES256-SHA384", "priority": 9},
{"name": "ECDHE-RSA-AES256-SHA384", "priority": 10},
{"name": "ECDHE-RSA-AES256-SHA", "priority": 11},
{"name": "ECDHE-ECDSA-AES256-SHA", "priority": 12},
{"name": "AES128-GCM-SHA256", "priority": 13},
{"name": "AES128-SHA256", "priority": 14},
{"name": "AES128-SHA", "priority": 15},
{"name": "AES256-GCM-SHA384", "priority": 16},
{"name": "AES256-SHA256", "priority": 17},
{"name": "AES256-SHA", "priority": 18},
],
},
{
"name": "ELBSecurityPolicy-2015-05",
"ssl_protocols": ["TLSv1", "TLSv1.1", "TLSv1.2"],
"ciphers": [
{"name": "ECDHE-ECDSA-AES128-GCM-SHA256", "priority": 1},
{"name": "ECDHE-RSA-AES128-GCM-SHA256", "priority": 2},
{"name": "ECDHE-ECDSA-AES128-SHA256", "priority": 3},
{"name": "ECDHE-RSA-AES128-SHA256", "priority": 4},
{"name": "ECDHE-ECDSA-AES128-SHA", "priority": 5},
{"name": "ECDHE-RSA-AES128-SHA", "priority": 6},
{"name": "ECDHE-ECDSA-AES256-GCM-SHA384", "priority": 7},
{"name": "ECDHE-RSA-AES256-GCM-SHA384", "priority": 8},
{"name": "ECDHE-ECDSA-AES256-SHA384", "priority": 9},
{"name": "ECDHE-RSA-AES256-SHA384", "priority": 10},
{"name": "ECDHE-RSA-AES256-SHA", "priority": 11},
{"name": "ECDHE-ECDSA-AES256-SHA", "priority": 12},
{"name": "AES128-GCM-SHA256", "priority": 13},
{"name": "AES128-SHA256", "priority": 14},
{"name": "AES128-SHA", "priority": 15},
{"name": "AES256-GCM-SHA384", "priority": 16},
{"name": "AES256-SHA256", "priority": 17},
{"name": "AES256-SHA", "priority": 18},
],
},
{
"name": "ELBSecurityPolicy-TLS-1-0-2015-04",
"ssl_protocols": ["TLSv1", "TLSv1.1", "TLSv1.2"],
"ciphers": [
{"name": "ECDHE-ECDSA-AES128-GCM-SHA256", "priority": 1},
{"name": "ECDHE-RSA-AES128-GCM-SHA256", "priority": 2},
{"name": "ECDHE-ECDSA-AES128-SHA256", "priority": 3},
{"name": "ECDHE-RSA-AES128-SHA256", "priority": 4},
{"name": "ECDHE-ECDSA-AES128-SHA", "priority": 5},
{"name": "ECDHE-RSA-AES128-SHA", "priority": 6},
{"name": "ECDHE-ECDSA-AES256-GCM-SHA384", "priority": 7},
{"name": "ECDHE-RSA-AES256-GCM-SHA384", "priority": 8},
{"name": "ECDHE-ECDSA-AES256-SHA384", "priority": 9},
{"name": "ECDHE-RSA-AES256-SHA384", "priority": 10},
{"name": "ECDHE-RSA-AES256-SHA", "priority": 11},
{"name": "ECDHE-ECDSA-AES256-SHA", "priority": 12},
{"name": "AES128-GCM-SHA256", "priority": 13},
{"name": "AES128-SHA256", "priority": 14},
{"name": "AES128-SHA", "priority": 15},
{"name": "AES256-GCM-SHA384", "priority": 16},
{"name": "AES256-SHA256", "priority": 17},
{"name": "AES256-SHA", "priority": 18},
{"name": "DES-CBC3-SHA", "priority": 19},
],
},
]
class ELBV2Response(BaseResponse):
@property
def elbv2_backend(self):
return elbv2_backends[self.region]
@amzn_request_id
def create_load_balancer(self):
load_balancer_name = self._get_param("Name")
subnet_ids = self._get_multi_param("Subnets.member")
security_groups = self._get_multi_param("SecurityGroups.member")
scheme = self._get_param("Scheme")
load_balancer = self.elbv2_backend.create_load_balancer(
name=load_balancer_name,
security_groups=security_groups,
subnet_ids=subnet_ids,
scheme=scheme,
)
self._add_tags(load_balancer)
template = self.response_template(CREATE_LOAD_BALANCER_TEMPLATE)
return template.render(load_balancer=load_balancer)
@amzn_request_id
def create_rule(self):
lister_arn = self._get_param("ListenerArn")
_conditions = self._get_list_prefix("Conditions.member")
conditions = []
for _condition in _conditions:
condition = {}
condition["field"] = _condition["field"]
values = sorted(
[e for e in _condition.items() if "values.member" in e[0]],
key=lambda x: x[0],
)
condition["values"] = []
# fix: preserve original request dict items, instead of flattening everything into "values" list
from moto.config.models import snake_to_camels
for entry in values:
if entry[0].startswith('values.member'):
condition["values"].append(entry[1])
else:
prefix, _, foo = entry[0].partition('.')
prefix = snake_to_camels(prefix, cap_start=False, cap_arn=False)
condition[prefix] = condition.get(prefix) or {'values': []}
if entry[0].endswith('._key'):
condition[prefix]['values'].append({'Key': entry[1],
'Value': _condition.get(entry[0].replace('._key', '._value'))})
elif entry[0].endswith('._value'):
pass # skip, already covered above
else:
condition[prefix]['values'].append(entry[1])
# condition["values"] = [e[1] for e in values]
conditions.append(condition)
priority = self._get_int_param("Priority")
actions = self._get_list_prefix("Actions.member")
rules = self.elbv2_backend.create_rule(
listener_arn=lister_arn,
conditions=conditions,
priority=priority,
actions=actions,
)
template = self.response_template(CREATE_RULE_TEMPLATE)
return template.render(rules=rules)
@amzn_request_id
def create_target_group(self):
name = self._get_param("Name")
vpc_id = self._get_param("VpcId")
protocol = self._get_param("Protocol")
port = self._get_param("Port")
healthcheck_protocol = self._get_param("HealthCheckProtocol")
healthcheck_port = self._get_param("HealthCheckPort")
healthcheck_path = self._get_param("HealthCheckPath")
healthcheck_interval_seconds = self._get_param("HealthCheckIntervalSeconds")
healthcheck_timeout_seconds = self._get_param("HealthCheckTimeoutSeconds")
healthy_threshold_count = self._get_param("HealthyThresholdCount")
unhealthy_threshold_count = self._get_param("UnhealthyThresholdCount")
matcher = self._get_param("Matcher")
target_type = self._get_param("TargetType")
target_group = self.elbv2_backend.create_target_group(
name,
vpc_id=vpc_id,
protocol=protocol,
port=port,
healthcheck_protocol=healthcheck_protocol,
healthcheck_port=healthcheck_port,
healthcheck_path=healthcheck_path,
healthcheck_interval_seconds=healthcheck_interval_seconds,
healthcheck_timeout_seconds=healthcheck_timeout_seconds,
healthy_threshold_count=healthy_threshold_count,
unhealthy_threshold_count=unhealthy_threshold_count,
matcher=matcher,
target_type=target_type,
)
template = self.response_template(CREATE_TARGET_GROUP_TEMPLATE)
return template.render(target_group=target_group)
@amzn_request_id
def create_listener(self):
load_balancer_arn = self._get_param("LoadBalancerArn")
protocol = self._get_param("Protocol")
port = self._get_param("Port")
ssl_policy = self._get_param("SslPolicy", "ELBSecurityPolicy-2016-08")
certificates = self._get_list_prefix("Certificates.member")
if certificates:
certificate = certificates[0].get("certificate_arn")
else:
certificate = None
default_actions = self._get_list_prefix("DefaultActions.member")
listener = self.elbv2_backend.create_listener(
load_balancer_arn=load_balancer_arn,
protocol=protocol,
port=port,
ssl_policy=ssl_policy,
certificate=certificate,
default_actions=default_actions,
)
template = self.response_template(CREATE_LISTENER_TEMPLATE)
return template.render(listener=listener)
@amzn_request_id
def describe_load_balancers(self):
arns = self._get_multi_param("LoadBalancerArns.member")
names = self._get_multi_param("Names.member")
all_load_balancers = list(
self.elbv2_backend.describe_load_balancers(arns, names)
)
marker = self._get_param("Marker")
all_names = [balancer.name for balancer in all_load_balancers]
if marker:
start = all_names.index(marker) + 1
else:
start = 0
page_size = self._get_int_param(
"PageSize", 50
) # the default is 400, but using 50 to make testing easier
load_balancers_resp = all_load_balancers[start : start + page_size]
next_marker = None
if len(all_load_balancers) > start + page_size:
next_marker = load_balancers_resp[-1].name
template = self.response_template(DESCRIBE_LOAD_BALANCERS_TEMPLATE)
return template.render(load_balancers=load_balancers_resp, marker=next_marker)
@amzn_request_id
def describe_rules(self):
listener_arn = self._get_param("ListenerArn")
rule_arns = (
self._get_multi_param("RuleArns.member")
if any(
k
for k in list(self.querystring.keys())
if k.startswith("RuleArns.member")
)
else None
)
all_rules = self.elbv2_backend.describe_rules(listener_arn, rule_arns)
all_arns = [rule.arn for rule in all_rules]
page_size = self._get_int_param("PageSize", 50) # set 50 for temporary
marker = self._get_param("Marker")
if marker:
start = all_arns.index(marker) + 1
else:
start = 0
rules_resp = all_rules[start : start + page_size]
next_marker = None
if len(all_rules) > start + page_size:
next_marker = rules_resp[-1].arn
template = self.response_template(DESCRIBE_RULES_TEMPLATE)
return template.render(rules=rules_resp, marker=next_marker)
@amzn_request_id
def describe_target_groups(self):
load_balancer_arn = self._get_param("LoadBalancerArn")
target_group_arns = self._get_multi_param("TargetGroupArns.member")
names = self._get_multi_param("Names.member")
target_groups = self.elbv2_backend.describe_target_groups(
load_balancer_arn, target_group_arns, names
)
template = self.response_template(DESCRIBE_TARGET_GROUPS_TEMPLATE)
return template.render(target_groups=target_groups)
@amzn_request_id
def describe_target_group_attributes(self):
target_group_arn = self._get_param("TargetGroupArn")
target_group = self.elbv2_backend.target_groups.get(target_group_arn)
if not target_group:
raise TargetGroupNotFoundError()
template = self.response_template(DESCRIBE_TARGET_GROUP_ATTRIBUTES_TEMPLATE)
return template.render(attributes=target_group.attributes)
@amzn_request_id
def describe_listeners(self):
load_balancer_arn = self._get_param("LoadBalancerArn")
listener_arns = self._get_multi_param("ListenerArns.member")
if not load_balancer_arn and not listener_arns:
raise LoadBalancerNotFoundError()
listeners = self.elbv2_backend.describe_listeners(
load_balancer_arn, listener_arns
)
template = self.response_template(DESCRIBE_LISTENERS_TEMPLATE)
return template.render(listeners=listeners)
@amzn_request_id
def delete_load_balancer(self):
arn = self._get_param("LoadBalancerArn")
self.elbv2_backend.delete_load_balancer(arn)
template = self.response_template(DELETE_LOAD_BALANCER_TEMPLATE)
return template.render()
@amzn_request_id
def delete_rule(self):
arn = self._get_param("RuleArn")
self.elbv2_backend.delete_rule(arn)
template = self.response_template(DELETE_RULE_TEMPLATE)
return template.render()
@amzn_request_id
def delete_target_group(self):
arn = self._get_param("TargetGroupArn")
self.elbv2_backend.delete_target_group(arn)
template = self.response_template(DELETE_TARGET_GROUP_TEMPLATE)
return template.render()
@amzn_request_id
def delete_listener(self):
arn = self._get_param("ListenerArn")
self.elbv2_backend.delete_listener(arn)
template = self.response_template(DELETE_LISTENER_TEMPLATE)
return template.render()
@amzn_request_id
def modify_rule(self):
rule_arn = self._get_param("RuleArn")
_conditions = self._get_list_prefix("Conditions.member")
conditions = []
for _condition in _conditions:
condition = {}
condition["field"] = _condition["field"]
values = sorted(
[e for e in _condition.items() if "values.member" in e[0]],
key=lambda x: x[0],
)
condition["values"] = [e[1] for e in values]
conditions.append(condition)
actions = self._get_list_prefix("Actions.member")
rules = self.elbv2_backend.modify_rule(
rule_arn=rule_arn, conditions=conditions, actions=actions
)
template = self.response_template(MODIFY_RULE_TEMPLATE)
return template.render(rules=rules)
@amzn_request_id
def modify_target_group_attributes(self):
target_group_arn = self._get_param("TargetGroupArn")
target_group = self.elbv2_backend.target_groups.get(target_group_arn)
attributes = {
attr["key"]: attr["value"]
for attr in self._get_list_prefix("Attributes.member")
}
target_group.attributes.update(attributes)
if not target_group:
raise TargetGroupNotFoundError()
template = self.response_template(MODIFY_TARGET_GROUP_ATTRIBUTES_TEMPLATE)
return template.render(attributes=attributes)
@amzn_request_id
def register_targets(self):
target_group_arn = self._get_param("TargetGroupArn")
targets = self._get_list_prefix("Targets.member")
self.elbv2_backend.register_targets(target_group_arn, targets)
template = self.response_template(REGISTER_TARGETS_TEMPLATE)
return template.render()
@amzn_request_id
def deregister_targets(self):
target_group_arn = self._get_param("TargetGroupArn")
targets = self._get_list_prefix("Targets.member")
self.elbv2_backend.deregister_targets(target_group_arn, targets)
template = self.response_template(DEREGISTER_TARGETS_TEMPLATE)
return template.render()
@amzn_request_id
def describe_target_health(self):
target_group_arn = self._get_param("TargetGroupArn")
targets = self._get_list_prefix("Targets.member")
target_health_descriptions = self.elbv2_backend.describe_target_health(
target_group_arn, targets
)
template = self.response_template(DESCRIBE_TARGET_HEALTH_TEMPLATE)
return template.render(target_health_descriptions=target_health_descriptions)
@amzn_request_id
def set_rule_priorities(self):
rule_priorities = self._get_list_prefix("RulePriorities.member")
for rule_priority in rule_priorities:
rule_priority["priority"] = int(rule_priority["priority"])
rules = self.elbv2_backend.set_rule_priorities(rule_priorities)
template = self.response_template(SET_RULE_PRIORITIES_TEMPLATE)
return template.render(rules=rules)
@amzn_request_id
def add_tags(self):
resource_arns = self._get_multi_param("ResourceArns.member")
for arn in resource_arns:
if ":targetgroup" in arn:
resource = self.elbv2_backend.target_groups.get(arn)
if not resource:
raise TargetGroupNotFoundError()
elif ":loadbalancer" in arn:
resource = self.elbv2_backend.load_balancers.get(arn)
if not resource:
raise LoadBalancerNotFoundError()
else:
raise LoadBalancerNotFoundError()
self._add_tags(resource)
template = self.response_template(ADD_TAGS_TEMPLATE)
return template.render()
@amzn_request_id
def remove_tags(self):
resource_arns = self._get_multi_param("ResourceArns.member")
tag_keys = self._get_multi_param("TagKeys.member")
for arn in resource_arns:
if ":targetgroup" in arn:
resource = self.elbv2_backend.target_groups.get(arn)
if not resource:
raise TargetGroupNotFoundError()
elif ":loadbalancer" in arn:
resource = self.elbv2_backend.load_balancers.get(arn)
if not resource:
raise LoadBalancerNotFoundError()
else:
raise LoadBalancerNotFoundError()
[resource.remove_tag(key) for key in tag_keys]
template = self.response_template(REMOVE_TAGS_TEMPLATE)
return template.render()
@amzn_request_id
def describe_tags(self):
resource_arns = self._get_multi_param("ResourceArns.member")
resources = []
for arn in resource_arns:
if ":targetgroup" in arn:
resource = self.elbv2_backend.target_groups.get(arn)
if not resource:
raise TargetGroupNotFoundError()
elif ":loadbalancer" in arn:
resource = self.elbv2_backend.load_balancers.get(arn)
if not resource:
raise LoadBalancerNotFoundError()
else:
raise LoadBalancerNotFoundError()
resources.append(resource)
template = self.response_template(DESCRIBE_TAGS_TEMPLATE)
return template.render(resources=resources)
@amzn_request_id
def describe_account_limits(self):
# Supports paging but not worth implementing yet
# marker = self._get_param('Marker')
# page_size = self._get_int_param('PageSize')
limits = {
"application-load-balancers": 20,
"target-groups": 3000,
"targets-per-application-load-balancer": 30,
"listeners-per-application-load-balancer": 50,
"rules-per-application-load-balancer": 100,
"network-load-balancers": 20,
"targets-per-network-load-balancer": 200,
"listeners-per-network-load-balancer": 50,
}
template = self.response_template(DESCRIBE_LIMITS_TEMPLATE)
return template.render(limits=limits)
@amzn_request_id
def describe_ssl_policies(self):
names = self._get_multi_param("Names.member.")
# Supports paging but not worth implementing yet
# marker = self._get_param('Marker')
# page_size = self._get_int_param('PageSize')
policies = SSL_POLICIES
if names:
policies = filter(lambda policy: policy["name"] in names, policies)
template = self.response_template(DESCRIBE_SSL_POLICIES_TEMPLATE)
return template.render(policies=policies)
@amzn_request_id
def set_ip_address_type(self):
arn = self._get_param("LoadBalancerArn")
ip_type = self._get_param("IpAddressType")
self.elbv2_backend.set_ip_address_type(arn, ip_type)
template = self.response_template(SET_IP_ADDRESS_TYPE_TEMPLATE)
return template.render(ip_type=ip_type)
@amzn_request_id
def set_security_groups(self):
arn = self._get_param("LoadBalancerArn")
sec_groups = self._get_multi_param("SecurityGroups.member.")
self.elbv2_backend.set_security_groups(arn, sec_groups)
template = self.response_template(SET_SECURITY_GROUPS_TEMPLATE)
return template.render(sec_groups=sec_groups)
@amzn_request_id
def set_subnets(self):
arn = self._get_param("LoadBalancerArn")
subnets = self._get_multi_param("Subnets.member.")
subnet_zone_list = self.elbv2_backend.set_subnets(arn, subnets)
template = self.response_template(SET_SUBNETS_TEMPLATE)
return template.render(subnets=subnet_zone_list)
@amzn_request_id
def modify_load_balancer_attributes(self):
arn = self._get_param("LoadBalancerArn")
attrs = self._get_map_prefix(
"Attributes.member", key_end="Key", value_end="Value"
)
all_attrs = self.elbv2_backend.modify_load_balancer_attributes(arn, attrs)
template = self.response_template(MODIFY_LOADBALANCER_ATTRS_TEMPLATE)
return template.render(attrs=all_attrs)
@amzn_request_id
def describe_load_balancer_attributes(self):
arn = self._get_param("LoadBalancerArn")
attrs = self.elbv2_backend.describe_load_balancer_attributes(arn)
template = self.response_template(DESCRIBE_LOADBALANCER_ATTRS_TEMPLATE)
return template.render(attrs=attrs)
@amzn_request_id
def modify_target_group(self):
arn = self._get_param("TargetGroupArn")
health_check_proto = self._get_param(
"HealthCheckProtocol"
) # 'HTTP' | 'HTTPS' | 'TCP',
health_check_port = self._get_param("HealthCheckPort")
health_check_path = self._get_param("HealthCheckPath")
health_check_interval = self._get_param("HealthCheckIntervalSeconds")
health_check_timeout = self._get_param("HealthCheckTimeoutSeconds")
healthy_threshold_count = self._get_param("HealthyThresholdCount")
unhealthy_threshold_count = self._get_param("UnhealthyThresholdCount")
http_codes = self._get_param("Matcher.HttpCode")
target_group = self.elbv2_backend.modify_target_group(
arn,
health_check_proto,
health_check_port,
health_check_path,
health_check_interval,
health_check_timeout,
healthy_threshold_count,
unhealthy_threshold_count,
http_codes,
)
template = self.response_template(MODIFY_TARGET_GROUP_TEMPLATE)
return template.render(target_group=target_group)
@amzn_request_id
def modify_listener(self):
arn = self._get_param("ListenerArn")
port = self._get_param("Port")
protocol = self._get_param("Protocol")
ssl_policy = self._get_param("SslPolicy")
certificates = self._get_list_prefix("Certificates.member")
default_actions = self._get_list_prefix("DefaultActions.member")
# Should really move SSL Policies to models
if ssl_policy is not None and ssl_policy not in [
item["name"] for item in SSL_POLICIES
]:
raise RESTError(
"SSLPolicyNotFound", "Policy {0} not found".format(ssl_policy)
)
listener = self.elbv2_backend.modify_listener(
arn, port, protocol, ssl_policy, certificates, default_actions
)
template = self.response_template(MODIFY_LISTENER_TEMPLATE)
return template.render(listener=listener)
def _add_tags(self, resource):
tag_values = []
tag_keys = []
for t_key, t_val in sorted(self.querystring.items()):
if t_key.startswith("Tags.member."):
if t_key.split(".")[3] == "Key":
tag_keys.extend(t_val)
elif t_key.split(".")[3] == "Value":
tag_values.extend(t_val)
counts = {}
for i in tag_keys:
counts[i] = tag_keys.count(i)
counts = sorted(counts.items(), key=lambda i: i[1], reverse=True)
if counts and counts[0][1] > 1:
# We have dupes...
raise DuplicateTagKeysError(counts[0])
for tag_key, tag_value in zip(tag_keys, tag_values):
resource.add_tag(tag_key, tag_value)
ADD_TAGS_TEMPLATE = """<AddTagsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<AddTagsResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</AddTagsResponse>"""
REMOVE_TAGS_TEMPLATE = """<RemoveTagsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<RemoveTagsResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</RemoveTagsResponse>"""
DESCRIBE_TAGS_TEMPLATE = """<DescribeTagsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeTagsResult>
<TagDescriptions>
{% for resource in resources %}
<member>
<ResourceArn>{{ resource.arn }}</ResourceArn>
<Tags>
{% for key, value in resource.tags.items() %}
<member>
<Value>{{ value }}</Value>
<Key>{{ key }}</Key>
</member>
{% endfor %}
</Tags>
</member>
{% endfor %}
</TagDescriptions>
</DescribeTagsResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeTagsResponse>"""
CREATE_LOAD_BALANCER_TEMPLATE = """<CreateLoadBalancerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<CreateLoadBalancerResult>
<LoadBalancers>
<member>
<LoadBalancerArn>{{ load_balancer.arn }}</LoadBalancerArn>
<Scheme>{{ load_balancer.scheme }}</Scheme>
<LoadBalancerName>{{ load_balancer.name }}</LoadBalancerName>
<VpcId>{{ load_balancer.vpc_id }}</VpcId>
<CanonicalHostedZoneId>Z2P70J7EXAMPLE</CanonicalHostedZoneId>
<CreatedTime>{{ load_balancer.created_time }}</CreatedTime>
<AvailabilityZones>
{% for subnet in load_balancer.subnets %}
<member>
<SubnetId>{{ subnet.id }}</SubnetId>
<ZoneName>{{ subnet.availability_zone }}</ZoneName>
</member>
{% endfor %}
</AvailabilityZones>
<SecurityGroups>
{% for security_group in load_balancer.security_groups %}
<member>{{ security_group }}</member>
{% endfor %}
</SecurityGroups>
<DNSName>{{ load_balancer.dns_name }}</DNSName>
<State>
<Code>{{ load_balancer.state }}</Code>
</State>
<Type>application</Type>
</member>
</LoadBalancers>
</CreateLoadBalancerResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</CreateLoadBalancerResponse>"""
CREATE_RULE_TEMPLATE = """<CreateRuleResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<CreateRuleResult>
<Rules>
{% for rule in rules %}
<member>
<IsDefault>{{ "true" if rule.is_default else "false" }}</IsDefault>
<Conditions>
{% for condition in rule.conditions %}
<member>
<Field>{{ condition["field"] }}</Field>
<Values>
{% for value in condition["values"] %}
<member>{{ value }}</member>
{% endfor %}
</Values>
</member>
{% endfor %}
</Conditions>
<Priority>{{ rule.priority }}</Priority>
<Actions>
{% for action in rule.actions %}
<member>
<Type>{{ action["type"] }}</Type>
{% if action["type"] == "forward" %}
<TargetGroupArn>{{ action["target_group_arn"] }}</TargetGroupArn>
{% elif action["type"] == "redirect" %}
<RedirectConfig>{{ action["redirect_config"] }}</RedirectConfig>
{% endif %}
</member>
{% endfor %}
</Actions>
<RuleArn>{{ rule.arn }}</RuleArn>
</member>
{% endfor %}
</Rules>
</CreateRuleResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</CreateRuleResponse>"""
CREATE_TARGET_GROUP_TEMPLATE = """<CreateTargetGroupResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<CreateTargetGroupResult>
<TargetGroups>
<member>
<TargetGroupArn>{{ target_group.arn }}</TargetGroupArn>
<TargetGroupName>{{ target_group.name }}</TargetGroupName>
<Protocol>{{ target_group.protocol }}</Protocol>
<Port>{{ target_group.port }}</Port>
<VpcId>{{ target_group.vpc_id }}</VpcId>
<HealthCheckProtocol>{{ target_group.health_check_protocol }}</HealthCheckProtocol>
<HealthCheckPort>{{ target_group.healthcheck_port }}</HealthCheckPort>
<HealthCheckPath>{{ target_group.healthcheck_path }}</HealthCheckPath>
<HealthCheckIntervalSeconds>{{ target_group.healthcheck_interval_seconds }}</HealthCheckIntervalSeconds>
<HealthCheckTimeoutSeconds>{{ target_group.healthcheck_timeout_seconds }}</HealthCheckTimeoutSeconds>
<HealthyThresholdCount>{{ target_group.healthy_threshold_count }}</HealthyThresholdCount>
<UnhealthyThresholdCount>{{ target_group.unhealthy_threshold_count }}</UnhealthyThresholdCount>
{% if target_group.matcher %}
<Matcher>
<HttpCode>{{ target_group.matcher['HttpCode'] }}</HttpCode>
</Matcher>
{% endif %}
{% if target_group.target_type %}
<TargetType>{{ target_group.target_type }}</TargetType>
{% endif %}
</member>
</TargetGroups>
</CreateTargetGroupResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</CreateTargetGroupResponse>"""
CREATE_LISTENER_TEMPLATE = """<CreateListenerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<CreateListenerResult>
<Listeners>
<member>
<LoadBalancerArn>{{ listener.load_balancer_arn }}</LoadBalancerArn>
<Protocol>{{ listener.protocol }}</Protocol>
{% if listener.certificates %}
<Certificates>
{% for cert in listener.certificates %}
<member>
<CertificateArn>{{ cert }}</CertificateArn>
</member>
{% endfor %}
</Certificates>
{% endif %}
<Port>{{ listener.port }}</Port>
<SslPolicy>{{ listener.ssl_policy }}</SslPolicy>
<ListenerArn>{{ listener.arn }}</ListenerArn>
<DefaultActions>
{% for action in listener.default_actions %}
<member>
{{ action.to_xml() }}
</member>
{% endfor %}
</DefaultActions>
</member>
</Listeners>
</CreateListenerResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</CreateListenerResponse>"""
DELETE_LOAD_BALANCER_TEMPLATE = """<DeleteLoadBalancerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DeleteLoadBalancerResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DeleteLoadBalancerResponse>"""
DELETE_RULE_TEMPLATE = """<DeleteRuleResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DeleteRuleResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DeleteRuleResponse>"""
DELETE_TARGET_GROUP_TEMPLATE = """<DeleteTargetGroupResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DeleteTargetGroupResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DeleteTargetGroupResponse>"""
DELETE_LISTENER_TEMPLATE = """<DeleteListenerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DeleteListenerResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DeleteListenerResponse>"""
DESCRIBE_LOAD_BALANCERS_TEMPLATE = """<DescribeLoadBalancersResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeLoadBalancersResult>
<LoadBalancers>
{% for load_balancer in load_balancers %}
<member>
<LoadBalancerArn>{{ load_balancer.arn }}</LoadBalancerArn>
<Scheme>{{ load_balancer.scheme }}</Scheme>
<LoadBalancerName>{{ load_balancer.name }}</LoadBalancerName>
<VpcId>{{ load_balancer.vpc_id }}</VpcId>
<CanonicalHostedZoneId>Z2P70J7EXAMPLE</CanonicalHostedZoneId>
<CreatedTime>{{ load_balancer.created_time }}</CreatedTime>
<AvailabilityZones>
{% for subnet in load_balancer.subnets %}
<member>
<SubnetId>{{ subnet.id }}</SubnetId>
<ZoneName>{{ subnet.availability_zone }}</ZoneName>
</member>
{% endfor %}
</AvailabilityZones>
<SecurityGroups>
{% for security_group in load_balancer.security_groups %}
<member>{{ security_group }}</member>
{% endfor %}
</SecurityGroups>
<DNSName>{{ load_balancer.dns_name }}</DNSName>
<State>
<Code>{{ load_balancer.state }}</Code>
</State>
<Type>application</Type>
<IpAddressType>ipv4</IpAddressType>
</member>
{% endfor %}
</LoadBalancers>
{% if marker %}
<NextMarker>{{ marker }}</NextMarker>
{% endif %}
</DescribeLoadBalancersResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeLoadBalancersResponse>"""
DESCRIBE_RULES_TEMPLATE = """<DescribeRulesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeRulesResult>
<Rules>
{% for rule in rules %}
<member>
<IsDefault>{{ "true" if rule.is_default else "false" }}</IsDefault>
<Conditions>
{% for condition in rule.conditions %}
<member>
<Field>{{ condition["field"] }}</Field>
<Values>
{% for value in condition["values"] %}
<member>{{ value }}</member>
{% endfor %}
</Values>
</member>
{% endfor %}
</Conditions>
<Priority>{{ rule.priority }}</Priority>
<Actions>
{% for action in rule.actions %}
<member>
{{ action.to_xml() }}
</member>
{% endfor %}
</Actions>
<RuleArn>{{ rule.arn }}</RuleArn>
</member>
{% endfor %}
</Rules>
{% if marker %}
<NextMarker>{{ marker }}</NextMarker>
{% endif %}
</DescribeRulesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeRulesResponse>"""
DESCRIBE_TARGET_GROUPS_TEMPLATE = """<DescribeTargetGroupsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeTargetGroupsResult>
<TargetGroups>
{% for target_group in target_groups %}
<member>
<TargetGroupArn>{{ target_group.arn }}</TargetGroupArn>
<TargetGroupName>{{ target_group.name }}</TargetGroupName>
<Protocol>{{ target_group.protocol }}</Protocol>
<Port>{{ target_group.port }}</Port>
<VpcId>{{ target_group.vpc_id }}</VpcId>
<HealthCheckProtocol>{{ target_group.healthcheck_protocol }}</HealthCheckProtocol>
<HealthCheckPort>{{ target_group.healthcheck_port }}</HealthCheckPort>
<HealthCheckPath>{{ target_group.healthcheck_path }}</HealthCheckPath>
<HealthCheckIntervalSeconds>{{ target_group.healthcheck_interval_seconds }}</HealthCheckIntervalSeconds>
<HealthCheckTimeoutSeconds>{{ target_group.healthcheck_timeout_seconds }}</HealthCheckTimeoutSeconds>
<HealthyThresholdCount>{{ target_group.healthy_threshold_count }}</HealthyThresholdCount>
<UnhealthyThresholdCount>{{ target_group.unhealthy_threshold_count }}</UnhealthyThresholdCount>
{% if target_group.matcher %}
<Matcher>
<HttpCode>{{ target_group.matcher['HttpCode'] }}</HttpCode>
</Matcher>
{% endif %}
{% if target_group.target_type %}
<TargetType>{{ target_group.target_type }}</TargetType>
{% endif %}
<LoadBalancerArns>
{% for load_balancer_arn in target_group.load_balancer_arns %}
<member>{{ load_balancer_arn }}</member>
{% endfor %}
</LoadBalancerArns>
</member>
{% endfor %}
</TargetGroups>
</DescribeTargetGroupsResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeTargetGroupsResponse>"""
DESCRIBE_TARGET_GROUP_ATTRIBUTES_TEMPLATE = """<DescribeTargetGroupAttributesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeTargetGroupAttributesResult>
<Attributes>
{% for key, value in attributes.items() %}
<member>
<Key>{{ key }}</Key>
<Value>{{ value }}</Value>
</member>
{% endfor %}
</Attributes>
</DescribeTargetGroupAttributesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeTargetGroupAttributesResponse>"""
DESCRIBE_LISTENERS_TEMPLATE = """<DescribeLoadBalancersResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeListenersResult>
<Listeners>
{% for listener in listeners %}
<member>
<LoadBalancerArn>{{ listener.load_balancer_arn }}</LoadBalancerArn>
<Protocol>{{ listener.protocol }}</Protocol>
{% if listener.certificate %}
<Certificates>
<member>
<CertificateArn>{{ listener.certificate }}</CertificateArn>
</member>
</Certificates>
{% endif %}
<Port>{{ listener.port }}</Port>
<SslPolicy>{{ listener.ssl_policy }}</SslPolicy>
<ListenerArn>{{ listener.arn }}</ListenerArn>
<DefaultActions>
{% for action in listener.default_actions %}
<member>
{{ action.to_xml() }}
</member>
{% endfor %}
</DefaultActions>
</member>
{% endfor %}
</Listeners>
</DescribeListenersResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeLoadBalancersResponse>"""
CONFIGURE_HEALTH_CHECK_TEMPLATE = """<ConfigureHealthCheckResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<ConfigureHealthCheckResult>
<HealthCheck>
<Interval>{{ check.interval }}</Interval>
<Target>{{ check.target }}</Target>
<HealthyThreshold>{{ check.healthy_threshold }}</HealthyThreshold>
<Timeout>{{ check.timeout }}</Timeout>
<UnhealthyThreshold>{{ check.unhealthy_threshold }}</UnhealthyThreshold>
</HealthCheck>
</ConfigureHealthCheckResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</ConfigureHealthCheckResponse>"""
MODIFY_RULE_TEMPLATE = """<ModifyRuleResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<ModifyRuleResult>
<Rules>
{% for rule in rules %}
<member>
<IsDefault>{{ "true" if rule.is_default else "false" }}</IsDefault>
<Conditions>
{% for condition in rule.conditions %}
<member>
<Field>{{ condition["field"] }}</Field>
<Values>
{% for value in condition["values"] %}
<member>{{ value }}</member>
{% endfor %}
</Values>
</member>
{% endfor %}
</Conditions>
<Priority>{{ rule.priority }}</Priority>
<Actions>
{% for action in rule.actions %}
<member>
{{ action.to_xml() }}
</member>
{% endfor %}
</Actions>
<RuleArn>{{ rule.arn }}</RuleArn>
</member>
{% endfor %}
</Rules>
</ModifyRuleResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</ModifyRuleResponse>"""
MODIFY_TARGET_GROUP_ATTRIBUTES_TEMPLATE = """<ModifyTargetGroupAttributesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<ModifyTargetGroupAttributesResult>
<Attributes>
{% for key, value in attributes.items() %}
<member>
<Key>{{ key }}</Key>
<Value>{{ value }}</Value>
</member>
{% endfor %}
</Attributes>
</ModifyTargetGroupAttributesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</ModifyTargetGroupAttributesResponse>"""
REGISTER_TARGETS_TEMPLATE = """<RegisterTargetsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<RegisterTargetsResult>
</RegisterTargetsResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</RegisterTargetsResponse>"""
DEREGISTER_TARGETS_TEMPLATE = """<DeregisterTargetsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DeregisterTargetsResult>
</DeregisterTargetsResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DeregisterTargetsResponse>"""
SET_LOAD_BALANCER_SSL_CERTIFICATE = """<SetLoadBalancerListenerSSLCertificateResponse xmlns="http://elasticloadbalan cing.amazonaws.com/doc/2015-12-01/">
<SetLoadBalancerListenerSSLCertificateResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</SetLoadBalancerListenerSSLCertificateResponse>"""
DELETE_LOAD_BALANCER_LISTENERS = """<DeleteLoadBalancerListenersResponse xmlns="http://elasticloadbalan cing.amazonaws.com/doc/2015-12-01/">
<DeleteLoadBalancerListenersResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DeleteLoadBalancerListenersResponse>"""
DESCRIBE_ATTRIBUTES_TEMPLATE = """<DescribeLoadBalancerAttributesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeLoadBalancerAttributesResult>
<LoadBalancerAttributes>
<AccessLog>
<Enabled>{{ attributes.access_log.enabled }}</Enabled>
{% if attributes.access_log.enabled %}
<S3BucketName>{{ attributes.access_log.s3_bucket_name }}</S3BucketName>
<S3BucketPrefix>{{ attributes.access_log.s3_bucket_prefix }}</S3BucketPrefix>
<EmitInterval>{{ attributes.access_log.emit_interval }}</EmitInterval>
{% endif %}
</AccessLog>
<ConnectionSettings>
<IdleTimeout>{{ attributes.connecting_settings.idle_timeout }}</IdleTimeout>
</ConnectionSettings>
<CrossZoneLoadBalancing>
<Enabled>{{ attributes.cross_zone_load_balancing.enabled }}</Enabled>
</CrossZoneLoadBalancing>
<ConnectionDraining>
{% if attributes.connection_draining.enabled %}
<Enabled>true</Enabled>
<Timeout>{{ attributes.connection_draining.timeout }}</Timeout>
{% else %}
<Enabled>false</Enabled>
{% endif %}
</ConnectionDraining>
</LoadBalancerAttributes>
</DescribeLoadBalancerAttributesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeLoadBalancerAttributesResponse>
"""
MODIFY_ATTRIBUTES_TEMPLATE = """<ModifyLoadBalancerAttributesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<ModifyLoadBalancerAttributesResult>
<LoadBalancerName>{{ load_balancer.name }}</LoadBalancerName>
<LoadBalancerAttributes>
<AccessLog>
<Enabled>{{ attributes.access_log.enabled }}</Enabled>
{% if attributes.access_log.enabled %}
<S3BucketName>{{ attributes.access_log.s3_bucket_name }}</S3BucketName>
<S3BucketPrefix>{{ attributes.access_log.s3_bucket_prefix }}</S3BucketPrefix>
<EmitInterval>{{ attributes.access_log.emit_interval }}</EmitInterval>
{% endif %}
</AccessLog>
<ConnectionSettings>
<IdleTimeout>{{ attributes.connecting_settings.idle_timeout }}</IdleTimeout>
</ConnectionSettings>
<CrossZoneLoadBalancing>
<Enabled>{{ attributes.cross_zone_load_balancing.enabled }}</Enabled>
</CrossZoneLoadBalancing>
<ConnectionDraining>
{% if attributes.connection_draining.enabled %}
<Enabled>true</Enabled>
<Timeout>{{ attributes.connection_draining.timeout }}</Timeout>
{% else %}
<Enabled>false</Enabled>
{% endif %}
</ConnectionDraining>
</LoadBalancerAttributes>
</ModifyLoadBalancerAttributesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</ModifyLoadBalancerAttributesResponse>
"""
CREATE_LOAD_BALANCER_POLICY_TEMPLATE = """<CreateLoadBalancerPolicyResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<CreateLoadBalancerPolicyResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</CreateLoadBalancerPolicyResponse>
"""
SET_LOAD_BALANCER_POLICIES_OF_LISTENER_TEMPLATE = """<SetLoadBalancerPoliciesOfListenerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<SetLoadBalancerPoliciesOfListenerResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</SetLoadBalancerPoliciesOfListenerResponse>
"""
SET_LOAD_BALANCER_POLICIES_FOR_BACKEND_SERVER_TEMPLATE = """<SetLoadBalancerPoliciesForBackendServerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<SetLoadBalancerPoliciesForBackendServerResult/>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</SetLoadBalancerPoliciesForBackendServerResponse>
"""
DESCRIBE_TARGET_HEALTH_TEMPLATE = """<DescribeTargetHealthResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeTargetHealthResult>
<TargetHealthDescriptions>
{% for target_health in target_health_descriptions %}
<member>
<HealthCheckPort>{{ target_health.health_port }}</HealthCheckPort>
<TargetHealth>
<State>{{ target_health.status }}</State>
{% if target_health.reason %}
<Reason>{{ target_health.reason }}</Reason>
{% endif %}
{% if target_health.description %}
<Description>{{ target_health.description }}</Description>
{% endif %}
</TargetHealth>
<Target>
<Port>{{ target_health.port }}</Port>
<Id>{{ target_health.instance_id }}</Id>
</Target>
</member>
{% endfor %}
</TargetHealthDescriptions>
</DescribeTargetHealthResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeTargetHealthResponse>"""
SET_RULE_PRIORITIES_TEMPLATE = """<SetRulePrioritiesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<SetRulePrioritiesResult>
<Rules>
{% for rule in rules %}
<member>
<IsDefault>{{ "true" if rule.is_default else "false" }}</IsDefault>
<Conditions>
{% for condition in rule.conditions %}
<member>
<Field>{{ condition["field"] }}</Field>
<Values>
{% for value in condition["values"] %}
<member>{{ value }}</member>
{% endfor %}
</Values>
</member>
{% endfor %}
</Conditions>
<Priority>{{ rule.priority }}</Priority>
<Actions>
{% for action in rule.actions %}
<member>
<Type>{{ action["type"] }}</Type>
<TargetGroupArn>{{ action["target_group_arn"] }}</TargetGroupArn>
</member>
{% endfor %}
</Actions>
<RuleArn>{{ rule.arn }}</RuleArn>
</member>
{% endfor %}
</Rules>
</SetRulePrioritiesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</SetRulePrioritiesResponse>"""
DESCRIBE_LIMITS_TEMPLATE = """<DescribeAccountLimitsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeAccountLimitsResult>
<Limits>
{% for key, value in limits.items() %}
<member>
<Name>{{ key }}</Name>
<Max>{{ value }}</Max>
</member>
{% endfor %}
</Limits>
</DescribeAccountLimitsResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeAccountLimitsResponse>"""
DESCRIBE_SSL_POLICIES_TEMPLATE = """<DescribeSSLPoliciesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeSSLPoliciesResult>
<SslPolicies>
{% for policy in policies %}
<member>
<Name>{{ policy['name'] }}</Name>
<Ciphers>
{% for cipher in policy['ciphers'] %}
<member>
<Name>{{ cipher['name'] }}</Name>
<Priority>{{ cipher['priority'] }}</Priority>
</member>
{% endfor %}
</Ciphers>
<SslProtocols>
{% for proto in policy['ssl_protocols'] %}
<member>{{ proto }}</member>
{% endfor %}
</SslProtocols>
</member>
{% endfor %}
</SslPolicies>
</DescribeSSLPoliciesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeSSLPoliciesResponse>"""
SET_IP_ADDRESS_TYPE_TEMPLATE = """<SetIpAddressTypeResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<SetIpAddressTypeResult>
<IpAddressType>{{ ip_type }}</IpAddressType>
</SetIpAddressTypeResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</SetIpAddressTypeResponse>"""
SET_SECURITY_GROUPS_TEMPLATE = """<SetSecurityGroupsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<SetSecurityGroupsResult>
<SecurityGroupIds>
{% for group in sec_groups %}
<member>{{ group }}</member>
{% endfor %}
</SecurityGroupIds>
</SetSecurityGroupsResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</SetSecurityGroupsResponse>"""
SET_SUBNETS_TEMPLATE = """<SetSubnetsResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<SetSubnetsResult>
<AvailabilityZones>
{% for zone_id, subnet_id in subnets %}
<member>
<SubnetId>{{ subnet_id }}</SubnetId>
<ZoneName>{{ zone_id }}</ZoneName>
</member>
{% endfor %}
</AvailabilityZones>
</SetSubnetsResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</SetSubnetsResponse>"""
MODIFY_LOADBALANCER_ATTRS_TEMPLATE = """<ModifyLoadBalancerAttributesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<ModifyLoadBalancerAttributesResult>
<Attributes>
{% for key, value in attrs.items() %}
<member>
{% if value == None %}<Value />{% else %}<Value>{{ value }}</Value>{% endif %}
<Key>{{ key }}</Key>
</member>
{% endfor %}
</Attributes>
</ModifyLoadBalancerAttributesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</ModifyLoadBalancerAttributesResponse>"""
DESCRIBE_LOADBALANCER_ATTRS_TEMPLATE = """<DescribeLoadBalancerAttributesResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<DescribeLoadBalancerAttributesResult>
<Attributes>
{% for key, value in attrs.items() %}
<member>
{% if value == None %}<Value />{% else %}<Value>{{ value }}</Value>{% endif %}
<Key>{{ key }}</Key>
</member>
{% endfor %}
</Attributes>
</DescribeLoadBalancerAttributesResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</DescribeLoadBalancerAttributesResponse>"""
MODIFY_TARGET_GROUP_TEMPLATE = """<ModifyTargetGroupResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<ModifyTargetGroupResult>
<TargetGroups>
<member>
<TargetGroupArn>{{ target_group.arn }}</TargetGroupArn>
<TargetGroupName>{{ target_group.name }}</TargetGroupName>
<Protocol>{{ target_group.protocol }}</Protocol>
<Port>{{ target_group.port }}</Port>
<VpcId>{{ target_group.vpc_id }}</VpcId>
<HealthCheckProtocol>{{ target_group.healthcheck_protocol }}</HealthCheckProtocol>
<HealthCheckPort>{{ target_group.healthcheck_port }}</HealthCheckPort>
<HealthCheckPath>{{ target_group.healthcheck_path }}</HealthCheckPath>
<HealthCheckIntervalSeconds>{{ target_group.healthcheck_interval_seconds }}</HealthCheckIntervalSeconds>
<HealthCheckTimeoutSeconds>{{ target_group.healthcheck_timeout_seconds }}</HealthCheckTimeoutSeconds>
<HealthyThresholdCount>{{ target_group.healthy_threshold_count }}</HealthyThresholdCount>
<UnhealthyThresholdCount>{{ target_group.unhealthy_threshold_count }}</UnhealthyThresholdCount>
<Matcher>
<HttpCode>{{ target_group.matcher['HttpCode'] }}</HttpCode>
</Matcher>
<LoadBalancerArns>
{% for load_balancer_arn in target_group.load_balancer_arns %}
<member>{{ load_balancer_arn }}</member>
{% endfor %}
</LoadBalancerArns>
</member>
</TargetGroups>
</ModifyTargetGroupResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</ModifyTargetGroupResponse>"""
MODIFY_LISTENER_TEMPLATE = """<ModifyListenerResponse xmlns="http://elasticloadbalancing.amazonaws.com/doc/2015-12-01/">
<ModifyListenerResult>
<Listeners>
<member>
<LoadBalancerArn>{{ listener.load_balancer_arn }}</LoadBalancerArn>
<Protocol>{{ listener.protocol }}</Protocol>
{% if listener.certificates %}
<Certificates>
{% for cert in listener.certificates %}
<member>
<CertificateArn>{{ cert }}</CertificateArn>
</member>
{% endfor %}
</Certificates>
{% endif %}
<Port>{{ listener.port }}</Port>
<SslPolicy>{{ listener.ssl_policy }}</SslPolicy>
<ListenerArn>{{ listener.arn }}</ListenerArn>
<DefaultActions>
{% for action in listener.default_actions %}
<member>
{{ action.to_xml() }}
</member>
{% endfor %}
</DefaultActions>
</member>
</Listeners>
</ModifyListenerResult>
<ResponseMetadata>
<RequestId>{{ request_id }}</RequestId>
</ResponseMetadata>
</ModifyListenerResponse>"""
| 39.569586 | 175 | 0.63511 |
6bcf16277d93f63bfb2613355b3f905595dbca57 | 48 | py | Python | blackpearl/__init__.py | offmessage/blackpearl | ffbba460fe7fc7fe4d7e3466f5ff13ea0c081fc5 | [
"MIT"
]
| null | null | null | blackpearl/__init__.py | offmessage/blackpearl | ffbba460fe7fc7fe4d7e3466f5ff13ea0c081fc5 | [
"MIT"
]
| null | null | null | blackpearl/__init__.py | offmessage/blackpearl | ffbba460fe7fc7fe4d7e3466f5ff13ea0c081fc5 | [
"MIT"
]
| null | null | null | """
Black Pearl: For twisted little pirates
"""
| 12 | 39 | 0.6875 |
d9fe585cd611ea27625ebe1b79ce87160bd612c9 | 13,334 | py | Python | bybit_backtest/bybit_backtest.py | 10mohi6/bybit-backtest-python | cea62f3c18d3c92bdb94efe9ccec95813002d74e | [
"MIT"
]
| 10 | 2020-10-24T18:12:57.000Z | 2022-03-12T07:34:18.000Z | bybit_backtest/bybit_backtest.py | 10mohi6/bybit-backtest-python | cea62f3c18d3c92bdb94efe9ccec95813002d74e | [
"MIT"
]
| null | null | null | bybit_backtest/bybit_backtest.py | 10mohi6/bybit-backtest-python | cea62f3c18d3c92bdb94efe9ccec95813002d74e | [
"MIT"
]
| 3 | 2021-11-02T05:30:13.000Z | 2022-02-01T21:24:42.000Z | from typing import Tuple
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import requests
from bs4 import BeautifulSoup
from sqlalchemy import create_engine
import urllib.request
import gzip
import datetime
class Backtest(object):
def __init__(
self,
*,
symbol: str = "BTCUSD",
sqlite_file_name: str = "backtest.sqlite3",
from_date: str = "",
to_date: str = "",
qty: float = 0.001,
interval: str = "1T", # 5-60S(second), 1-60T(minute), 1-24H(hour)
download_data_dir: str = "data",
) -> None:
self.interval = interval
self.download_data_dir = download_data_dir
self.qty = qty
self.take_profit = 0
self.stop_loss = 0
self.buy_entry = (
self.buy_exit
) = self.sell_entry = self.sell_exit = pd.DataFrame()
self.symbol = symbol
self.engine = create_engine(f"sqlite:///{sqlite_file_name}")
self.from_date = from_date
self.to_date = to_date
if not os.path.exists(self.download_data_dir):
os.mkdir(self.download_data_dir)
def strategy(self) -> None:
pass
def _download_data_to_db(self) -> None:
data_url = f"https://public.bybit.com/trading/{self.symbol}/"
res = requests.get(data_url)
if res.status_code != 200:
raise Exception(f"requests error {res.status_code} {res.json()}")
interval = "5S"
soup = BeautifulSoup(res.text, "lxml")
for link in soup.find_all("a"):
name = link.get("href")
if self.from_date != "" and f"{self.symbol}{self.from_date}.csv.gz" > name:
continue
if self.to_date != "" and f"{self.symbol}{self.to_date}.csv.gz" < name:
continue
fname = f"{self.download_data_dir}/{name}"
if os.path.exists(fname):
continue
data = urllib.request.urlopen(f"{data_url}{name}").read()
with open(fname, mode="wb") as f:
f.write(data)
print(f"Downloaded {name}")
json = []
with gzip.open(fname, mode="rt") as fp:
for index, line in enumerate(fp.read().split("\n")):
ary = line.split(",")
if index == 0:
continue
if len(line) == 0:
continue
json.append(
{
"time": datetime.datetime.fromtimestamp(
int(float(ary[0])), datetime.timezone.utc
),
"size": float(ary[3]),
"price": float(ary[4]),
}
)
df = pd.DataFrame(json)
df.index = pd.DatetimeIndex(df["time"])
df.index.names = ["T"]
df = (
df.resample(interval).agg(
{
"price": "ohlc",
"size": "sum",
}
)
).fillna(method="bfill")
df.columns = ["O", "H", "L", "C", "V"]
df.index.astype(str)
df.to_sql(self.symbol, con=self.engine, if_exists="append", index_label="T")
def _create_candles(self) -> None:
sql = ""
where = []
if self.from_date != "":
where.append(f" T >= '{self.from_date} 00:00:00' ")
if self.to_date != "":
where.append(f" T <= '{self.to_date} 00:00:00' ")
if len(where) > 0:
sql = f"WHERE{'and'.join(where)}"
self.df = pd.read_sql_query(
f"SELECT * FROM {self.symbol} {sql} ORDER BY T",
self.engine,
index_col="T",
)
self.df.index = pd.to_datetime(self.df.index)
if self.interval != "5S":
self.df = (
self.df.resample(self.interval).agg(
{
"O": "first",
"H": "max",
"L": "min",
"C": "last",
"V": "sum",
}
)
).fillna(method="bfill")
def run(self, filename: str = "") -> None:
self._download_data_to_db()
self._create_candles()
self.strategy()
o = self.df.O.values
L = self.df.L.values
h = self.df.H.values
N = len(self.df)
long_trade = np.zeros(N)
short_trade = np.zeros(N)
# buy entry
buy_entry_s = np.hstack((False, self.buy_entry[:-1])) # shift
long_trade[buy_entry_s] = o[buy_entry_s]
# buy exit
buy_exit_s = np.hstack((False, self.buy_exit[:-2], True)) # shift
long_trade[buy_exit_s] = -o[buy_exit_s]
# sell entry
sell_entry_s = np.hstack((False, self.sell_entry[:-1])) # shift
short_trade[sell_entry_s] = o[sell_entry_s]
# sell exit
sell_exit_s = np.hstack((False, self.sell_exit[:-2], True)) # shift
short_trade[sell_exit_s] = -o[sell_exit_s]
long_pl = pd.Series(np.zeros(N)) # profit/loss of buy position
short_pl = pd.Series(np.zeros(N)) # profit/loss of sell position
buy_price = sell_price = 0
long_rr = [] # long return rate
short_rr = [] # short return rate
stop_loss = take_profit = 0
for i in range(1, N):
# buy entry
if long_trade[i] > 0:
if buy_price == 0:
buy_price = long_trade[i]
short_trade[i] = -buy_price # sell exit
else:
long_trade[i] = 0
# sell entry
if short_trade[i] > 0:
if sell_price == 0:
sell_price = short_trade[i]
long_trade[i] = -sell_price # buy exit
else:
short_trade[i] = 0
# buy exit
if long_trade[i] < 0:
if buy_price != 0:
long_pl[i] = (
-(buy_price + long_trade[i]) * self.qty
) # profit/loss fixed
long_rr.append(
round(long_pl[i] / buy_price * 100, 2)
) # long return rate
buy_price = 0
else:
long_trade[i] = 0
# sell exit
if short_trade[i] < 0:
if sell_price != 0:
short_pl[i] = (
sell_price + short_trade[i]
) * self.qty # profit/loss fixed
short_rr.append(
round(short_pl[i] / sell_price * 100, 2)
) # short return rate
sell_price = 0
else:
short_trade[i] = 0
# close buy position with stop loss
if buy_price != 0 and self.stop_loss > 0:
stop_price = buy_price - self.stop_loss
if L[i] <= stop_price:
long_trade[i] = -stop_price
long_pl[i] = (
-(buy_price + long_trade[i]) * self.qty
) # profit/loss fixed
long_rr.append(
round(long_pl[i] / buy_price * 100, 2)
) # long return rate
buy_price = 0
stop_loss += 1
# close buy positon with take profit
if buy_price != 0 and self.take_profit > 0:
limit_price = buy_price + self.take_profit
if h[i] >= limit_price:
long_trade[i] = -limit_price
long_pl[i] = (
-(buy_price + long_trade[i]) * self.qty
) # profit/loss fixed
long_rr.append(
round(long_pl[i] / buy_price * 100, 2)
) # long return rate
buy_price = 0
take_profit += 1
# close sell position with stop loss
if sell_price != 0 and self.stop_loss > 0:
stop_price = sell_price + self.stop_loss
if h[i] >= stop_price:
short_trade[i] = -stop_price
short_pl[i] = (
sell_price + short_trade[i]
) * self.qty # profit/loss fixed
short_rr.append(
round(short_pl[i] / sell_price * 100, 2)
) # short return rate
sell_price = 0
stop_loss += 1
# close sell position with take profit
if sell_price != 0 and self.take_profit > 0:
limit_price = sell_price - self.take_profit
if L[i] <= limit_price:
short_trade[i] = -limit_price
short_pl[i] = (
sell_price + short_trade[i]
) * self.qty # profit/loss fixed
short_rr.append(
round(short_pl[i] / sell_price * 100, 2)
) # short return rate
sell_price = 0
take_profit += 1
win_trades = np.count_nonzero(long_pl.clip(lower=0)) + np.count_nonzero(
short_pl.clip(lower=0)
)
lose_trades = np.count_nonzero(long_pl.clip(upper=0)) + np.count_nonzero(
short_pl.clip(upper=0)
)
trades = (np.count_nonzero(long_trade) // 2) + (
np.count_nonzero(short_trade) // 2
)
gross_profit = long_pl.clip(lower=0).sum() + short_pl.clip(lower=0).sum()
gross_loss = long_pl.clip(upper=0).sum() + short_pl.clip(upper=0).sum()
profit_pl = gross_profit + gross_loss
self.equity = (long_pl + short_pl).cumsum()
mdd = (self.equity.cummax() - self.equity).max()
self.return_rate = pd.Series(short_rr + long_rr)
s = pd.Series(dtype="object")
s.loc["total profit"] = round(profit_pl, 3)
s.loc["total trades"] = trades
s.loc["win rate"] = round(win_trades / trades * 100, 3)
s.loc["profit factor"] = round(-gross_profit / gross_loss, 3)
s.loc["maximum drawdown"] = round(mdd, 3)
s.loc["recovery factor"] = round(profit_pl / mdd, 3)
s.loc["riskreward ratio"] = round(
-(gross_profit / win_trades) / (gross_loss / lose_trades), 3
)
s.loc["sharpe ratio"] = round(
self.return_rate.mean() / self.return_rate.std(), 3
)
s.loc["average return"] = round(self.return_rate.mean(), 3)
s.loc["stop loss"] = stop_loss
s.loc["take profit"] = take_profit
print(s)
fig = plt.figure(figsize=(8, 4))
fig.subplots_adjust(
wspace=0.2, hspace=0.5, left=0.095, right=0.95, bottom=0.095, top=0.95
)
ax1 = fig.add_subplot(3, 1, 1)
ax1.plot(self.df.C, label="close")
ax1.legend()
ax2 = fig.add_subplot(3, 1, 2)
ax2.plot(self.equity, label="equity")
ax2.legend()
ax3 = fig.add_subplot(3, 1, 3)
ax3.hist(self.return_rate, 50, rwidth=0.9)
ax3.axvline(
sum(self.return_rate) / len(self.return_rate),
color="orange",
label="average return",
)
ax3.legend()
if filename == "":
plt.show()
else:
plt.savefig(filename)
def sma(self, *, period: int, price: str = "C") -> pd.DataFrame:
return self.df[price].rolling(period).mean()
def ema(self, *, period: int, price: str = "C") -> pd.DataFrame:
return self.df[price].ewm(span=period).mean()
def bbands(
self, *, period: int = 20, band: int = 2, price: str = "C"
) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
std = self.df[price].rolling(period).std()
mean = self.df[price].rolling(period).mean()
return mean + (std * band), mean, mean - (std * band)
def macd(
self,
*,
fast_period: int = 12,
slow_period: int = 26,
signal_period: int = 9,
price: str = "C",
) -> Tuple[pd.DataFrame, pd.DataFrame]:
macd = (
self.df[price].ewm(span=fast_period).mean()
- self.df[price].ewm(span=slow_period).mean()
)
signal = macd.ewm(span=signal_period).mean()
return macd, signal
def stoch(
self, *, k_period: int = 5, d_period: int = 3
) -> Tuple[pd.DataFrame, pd.DataFrame]:
k = (
(self.df.C - self.df.L.rolling(k_period).min())
/ (self.df.H.rolling(k_period).max() - self.df.L.rolling(k_period).min())
* 100
)
d = k.rolling(d_period).mean()
return k, d
def rsi(self, *, period: int = 14, price: str = "C") -> pd.DataFrame:
return 100 - 100 / (
1
- self.df[price].diff().clip(lower=0).rolling(period).mean()
/ self.df[price].diff().clip(upper=0).rolling(period).mean()
)
| 37.455056 | 88 | 0.480051 |
aeab1d7f98630f88aff5e7258cb58c92ac9871c1 | 17,989 | py | Python | hoomd/cite.py | kmoskovtsev/HOOMD-Blue-fork | 99560563a5ba9e082b513764bae51a84f48fdc70 | [
"BSD-3-Clause"
]
| null | null | null | hoomd/cite.py | kmoskovtsev/HOOMD-Blue-fork | 99560563a5ba9e082b513764bae51a84f48fdc70 | [
"BSD-3-Clause"
]
| null | null | null | hoomd/cite.py | kmoskovtsev/HOOMD-Blue-fork | 99560563a5ba9e082b513764bae51a84f48fdc70 | [
"BSD-3-Clause"
]
| null | null | null | # Copyright (c) 2009-2016 The Regents of the University of Michigan
# This file is part of the HOOMD-blue project, released under the BSD 3-Clause License.
# Maintainer: mphoward / All Developers are free to add commands for new features
""" Commands to support automatic citation generation.
Certain features of HOOMD-blue should be cited because they represent significant contributions from developers.
In order to make these citations transparent and easy, HOOMD-blue will automatically print citation notices at run
time when you use a feature that should be cited. Users should read and cite these publications in their work.
Citations can be saved as a BibTeX file for easy incorporation into bibliographies.
"""
import hoomd
import textwrap
import os
## \internal
# \brief Generic citation object
# Objects representing specific BibTeX records derive from this object, which stores relevant citation information,
# and also supplies common methods for printing and saving these methods.
#
# Each deriving BibTeX record must supply the following:
# 1. __str__ to print the record in a human readable format
# 2. the string name for the BibTeX record
#
# Optionally, deriving objects may supply a list of BibTeX keys that are required. The record will then be validated
# for the existence of these keys when the record is added to a bibliography.
class _citation(object):
## \internal
# \brief Constructs a citation
# \param cite_key Unique key identifying this reference
# \param feature HOOMD functionality this citation corresponds to
# \param author Author or list of authors for this citation
# \param display Flag to automatically print the citation when adding to a bibliography
def __init__(self, cite_key, feature=None, author=None, display=False):
self.cite_key = cite_key
self.feature = feature
self.display = display
# author requires special handling for I/O
self.author = None
if author is not None:
if not isinstance(author, (list,tuple)):
self.author = [author]
else:
self.author = author
self.required_entries = []
self.bibtex_type = None
# initialize all standard keys as member variables
for key in _citation.standard_keys:
setattr(self,key,None)
# doi and url require special handling for I/O
self.doi = None
self.url = None
## \var cite_key
# \internal
# \brief Unique key identifying this reference
## \var feature
# \internal
# \brief String representation of the HOOMD functionality
## \var author
# \internal
# \brief List of authors
## \var required_entries
# \internal
# \brief List of BibTeX values that \b must be set in the record
## \var bibtex_type
# \internal
# \brief String for BibTeX record type
## \var doi
# \internal
# \brief The DOI for this citation
## \var url
# \internal
# \brief The URL for this citation (if web reference)
## \internal
# \brief Prints the citation as a human readable notice
def log(self):
if self.display is False:
return None
out = str(self)
if len(out) == 0:
return None # quit if there is nothing to actually log in this citation
wrapper = textwrap.TextWrapper(initial_indent = '* ', subsequent_indent = ' ', width = 80)
return wrapper.fill(out) + '\n'
## \internal
# \brief Get the citation in human readable format
# \note Deriving classes \b must implement this method themselves.
def __str__(self):
hoomd.context.msg.error('Bug in hoomd.cite: each deriving class must implement its own string method\n')
raise RuntimeError('Citation does not implement string method')
## \internal
# \brief Ensures that all required fields have been set
def validate(self):
for entry in self.required_entries:
if getattr(self,entry) is None:
hoomd.context.msg.error('Bug in hoomd.cite: required field %s not set, please report\n' % entry)
raise RuntimeError('Required citation field not set')
## \internal
# \brief Formats the author name list
# \param fancy Flag to print as a human readable list
# \returns Author list as a string or None if there are no authors
def format_authors(self, fancy=False):
if self.author is None:
return None
if len(self.author) > 1:
if not fancy:
return ' and '.join(self.author)
elif len(self.author) > 2:
return '%s, and %s' % (', '.join(self.author[:-1]), self.author[-1])
else:
return '%s and %s' % tuple(self.author)
else:
return self.author[0]
## \internal
# \brief Converts the citation to a BibTeX record
# \returns BibTeX record as a string
#
# If a DOI is set for the citation and no URL record has been specified, the URL is specified from the DOI.
# If no note is set for the citation, a default note identifying the HOOMD feature used is generated.
def bibtex(self):
if self.bibtex_type is None:
hoomd.context.msg.error('Bug in hoomd.cite: BibTeX record type must be set, please report\n')
raise RuntimeError()
lines = ['@%s{%s,' % (self.bibtex_type, self.cite_key)]
if self.author is not None:
lines += [' author = {%s},' % self.format_authors(False)]
for key in _citation.standard_keys:
val = getattr(self, key)
if getattr(self, key) is not None:
lines += [' %s = {%s},' % (key, val)]
# doi requires special handling because it is not "standard"
if self.doi is not None:
lines += [' doi = {%s},' % self.doi]
# only override the url with the doi if it is not set
if self.url is None and self.doi is not None:
lines += [' url = {http://dx.doi.org/%s},' % self.doi]
elif self.url is not None:
lines += [' url = {%s},' % self.url]
# add note based on the feature if a note has not been set
if self.feature is not None and self.note is None:
lines += [' note = {HOOMD-blue feature: %s},' % self.feature]
# remove trailing comma
lines[-1] = lines[-1][:-1]
# close off record
lines += ['}']
return '\n'.join(lines)
## \internal
# List of standard BibTeX keys that citations may use
_citation.standard_keys = ['address','annote','booktitle','chapter','crossref','edition','editor','howpublished',
'institution', 'journal','key','month','note','number','organization','pages','publisher',
'school','series','title', 'type','volume','year']
## \internal
# \brief Article BibTeX entry
class article(_citation):
## \internal
# \brief Creates an article entry
#
# \param cite_key Unique key identifying this reference
# \param author Author or list of authors for this citation
# \param title Article title
# \param journal Journal name (full or abbreviated)
# \param year Year of publication
# \param volume Journal volume
# \param pages Page range or article id
# \param number Journal issue number
# \param month Month of publication
# \param note Optional note on the article
# \param key Optional key
# \param doi Digital object identifier
# \param feature Name of HOOMD feature corresponding to citation
# \param display Flag to automatically print the citation when adding to a bibliography
def __init__(self, cite_key, author, title, journal, year, volume, pages, number=None, month=None, note=None, key=None, doi=None, feature=None, display=True):
_citation.__init__(self, cite_key, feature, author, display)
self.required_entries = ['author', 'title', 'journal', 'year', 'volume', 'pages']
self.bibtex_type = 'article'
self.title = title
self.journal = journal
self.year = year
self.volume = volume
self.number = number
self.pages = pages
self.month = month
self.note = note
self.key = key
self.doi = doi
def __str__(self):
out = ''
if self.author is not None:
out += self.format_authors(True)
out += '. '
out += '"%s", %s %s (%s) %s' % (self.title, self.journal, str(self.volume), str(self.year), str(self.pages))
return out
## \internal
# \brief Miscellaneous BibTeX entry
class misc(_citation):
## \internal
# \brief Creates a miscellaneous entry
#
# \param cite_key Unique key identifying this reference
# \param author Author or list of authors for this citation
# \param title Article title
# \param howpublished Format of publication (<i>e.g.</i> a url for a website)
# \param year Year of publication
# \param month Month of publication
# \param note Optional note on the article
# \param key Optional key
# \param feature Name of HOOMD feature corresponding to citation
# \param display Flag to automatically print the citation when adding to a bibliography
def __init__(self, cite_key, author=None, title=None, howpublished=None, year=None, month=None, note=None, key=None, feature=None, display=True):
_citation.__init__(self, cite_key, feature, author, display)
self.required_entries = []
self.bibtex_type = 'misc'
self.title = title
self.howpublished = howpublished
self.year = year
self.month = month
self.note = note
self.key = key
def __str__(self):
out = ''
if self.author is not None:
out += self.format_authors(True)
if self.title is not None:
if len(out) > 0:
out += '. '
out += '"%s"' % self.title
if self.howpublished is not None:
if len(out) > 0:
out += ', '
out += self.howpublished
if self.year is not None:
if len(out) > 0:
out += ' '
out += '(%s)' % str(year)
return out
## \internal
# \brief Collection of citations
#
# A %bibliography is a dictionary of citations. It ensures that each citation exists only once for a given key,
# and provides a mechanism for generating a BibTeX file. If two citations attempt to use the same citation key, only
# the most recent citation object is used for that entry.
class bibliography(object):
## \internal
# \brief Creates a bibliography
def __init__(self):
self.entries = {}
self.autosave = False
self.updated = False
self.file = 'hoomd.bib'
## \var entries
# \internal
# \brief Dictionary of citations
## \var autosave
# \internal
# \brief Flag marking if the bibliography should be saved to file on run time
## \var updated
# \internal
# \brief Flag marking if the bibliography has been updated since the last save
## \var file
# \internal
# \brief File name to use to save the bibliography
## \internal
# \brief Adds a citation, ensuring each key is only saved once
# \param entry Citation or list of citations to add to the bibliography
def add(self, entry):
# wrap the entry as a list if it is not
if not isinstance(entry, (list,tuple)):
entry = [entry]
# parse unique sets of features out of attached citations
citations = {}
for e in entry:
e.validate()
self.entries[e.cite_key] = e
log_str = e.log()
if log_str is not None: # if display is enabled and log returns an output
# if a feature is specified, we try to group them together into logical sets
if e.feature is not None:
if e.feature not in citations:
citations[e.feature] = [log_str]
else:
citations[e.feature] += [log_str]
else: # otherwise, just print the feature without any decoration
cite_str = '-'*5 + '\n'
cite_str += 'Please cite the following:\n'
cite_str += log_str
cite_str += '-'*5 + '\n'
hoomd.context.msg.notice(1, cite_str)
# print each feature set together
for feature in citations:
cite_str = '-'*5 + '\n'
cite_str += 'You are using %s. Please cite the following:\n' % feature
cite_str += ''.join(citations[feature])
cite_str += '-'*5 + '\n'
hoomd.context.msg.notice(1, cite_str)
# after adding, we need to update the file
self.updated = True
# if autosaving is enabled, bibliography should try to save itself to file
if self.autosave:
self.save()
## \internal
# \brief Saves the bibliography to file
def save(self):
if not self.should_save():
return
# dump all BibTeX entries to file (in no particular order)
f = open(self.file, 'w')
f.write('% This BibTeX file was automatically generated from HOOMD-blue\n')
f.write('% Encoding: UTF-8\n\n')
for entry in self.entries:
f.write(self.entries[entry].bibtex() + '\n\n')
f.close()
# after saving, we no longer need updating
self.updated = False
## \internal
# \brief Set parameters for saving the %bibliography file
# \param file %Bibliography file name
# \param autosave Flag to have %bibliography automatically saved as needed during run
#
# If \a autosave is true, the bibliography will be automatically saved to file each time a new citation is added.
def set_params(self, file=None, autosave=None):
if file is not None:
self.file = file
if autosave is not None:
self.autosave = autosave
## \internal
# \brief Determines if the current rank should save the bibliography file
def should_save(self):
# only the root rank should save the bibliography
if len(self.entries) == 0 or hoomd.comm.get_rank() != 0:
return False
# otherwise, check if the bibliography has been updated since last save
return self.updated
_extra_default_entries = []
## \internal
# \brief Ensures that the global bibliography is properly initialized
# \returns Global bibliography
#
# Citations generated in hoomd_script should always attach to a single global bibliography. This makes %bibliography
# generation invisible to the HOOMD users (that is, they should never actually instantiate a bibliography themselves).
# This function provides a convenient way to get the global bibliography while ensuring that it exists: if hoomd.context.bib
# already exists, it returns it. Otherwise, hoomd.context.bib is first created and then returned. Any %bibliography in HOOMD
# always includes two references: (1) the original HOOMD paper and (2) the HOOMD-blue website, which are automatically
# put into the global bibliography. Subsequent citations are then added to these citations.
def _ensure_global_bib():
global _extra_default_entries;
if hoomd.context.bib is None:
hoomd.context.bib = bibliography()
# the hoomd bibliography always includes the following citations
hoomd_base = article(cite_key = 'anderson2008',
author = ['J A Anderson','C D Lorenz','A Travesset'],
title = 'General purpose molecular dynamics simulations fully implemented on graphics processing units',
journal = 'Journal of Computational Physics',
volume = 227,
number = 10,
pages = '5342--5359',
year = 2008,
month = 'may',
doi = '10.1016/j.jcp.2008.01.047',
feature = 'HOOMD-blue')
hoomd_mpi = article(cite_key = 'glaser2015',
author = ['J Glaser',
'T D Nguyen',
'J A Anderson',
'P Liu',
'F Spiga',
'J A Millan',
'D C Morse',
'S C Glotzer'],
title = 'Strong scaling of general-purpose molecular dynamics simulations on GPUs',
journal = 'Computer Physics Communications',
volume = 192,
pages = '97--107',
year = 2015,
month = 'july',
doi = '10.1016/j.cpc.2015.02.028',
feature = 'HOOMD-blue')
hoomd.context.bib.add([hoomd_base, hoomd_mpi])
hoomd.context.bib.add(_extra_default_entries)
return hoomd.context.bib
def save(file='hoomd.bib'):
""" Saves the automatically generated bibliography to a BibTeX file
Args:
file(str): File name for the saved bibliography
After :py:func:`save()` is called for the first time, the bibliography will (re-)generate each time that a new feature is added
to ensure that all citations have been included. If ``file`` already exists, it will be overwritten.
Examples::
cite.save()
cite.save(file='cite.bib')
"""
hoomd.util.print_status_line()
# force a bibliography to exist
bib = _ensure_global_bib()
# update the bibliography save parameters
bib.set_params(file=file, autosave=True)
# save to file
bib.save()
| 38.686022 | 162 | 0.613097 |
b20ad9c57fce551c584bcd44f01d9d83a5b776dd | 29,336 | py | Python | pythran/tests/test_base.py | PierreBlancfat/pythran2 | 37869bc73aae1054253c2b1643aee5c63f11b7e8 | [
"BSD-3-Clause"
]
| null | null | null | pythran/tests/test_base.py | PierreBlancfat/pythran2 | 37869bc73aae1054253c2b1643aee5c63f11b7e8 | [
"BSD-3-Clause"
]
| null | null | null | pythran/tests/test_base.py | PierreBlancfat/pythran2 | 37869bc73aae1054253c2b1643aee5c63f11b7e8 | [
"BSD-3-Clause"
]
| null | null | null | import numpy
import sys
import unittest
from pythran.tests import TestEnv
from pythran.typing import *
class TestBase(TestEnv):
def test_pass(self):
self.run_test("def pass_(a):pass", 1, pass_=[int])
def test_empty_return(self):
self.run_test("def empty_return(a,b,c):return", 1,1.,True, empty_return=[int,float,bool])
def test_identity(self):
self.run_test("def identity(a): return a", 1.5, identity=[float])
def test_compare(self):
self.run_test("def compare(a,b,c):\n if a < b < c: return a\n else: return b != c", 1,2,3, compare=[int, int, int])
def test_arithmetic(self):
self.run_test("def arithmetic(a,b,c): return a+b*c", 1,2,3.3, arithmetic=[int,int, float])
def test_boolop(self):
self.run_test("def boolop(a,b,c): return a and b or c", True, True, False, boolop=[bool,bool, bool])
def test_operator(self):
self.run_test("def operator_(a,b,c): return (a+b-b*a//(a%b)**(a<<a>>b|b^a&a//b))/c",1,2,3., operator_=[int,int, float])
def test_unaryop(self):
self.run_test("def unaryop(a): return not(~(+(-a)))", 1, unaryop=[int])
def test_expression(self):
self.run_test("def expression(a,b,c): a+b*c", 1,2,3.3, expression=[int,int, float])
def test_recursion1(self):
code="""
def fibo(n): return n if n <2 else fibo(n-1) + fibo(n-2)
def fibo2(n): return fibo2(n-1) + fibo2(n-2) if n > 1 else n
"""
self.run_test(code, 4, fibo=[int])
def test_recursion2(self):
code="""
def fibo(n): return n if n <2 else fibo(n-1) + fibo(n-2)
def fibo2(n): return fibo2(n-1) + fibo2(n-2) if n > 1 else n
"""
self.run_test(code, 4., fibo2=[float])
def test_manual_list_comprehension(self):
self.run_test("def f(l):\n ll=list()\n for k in l:\n ll+=[k]\n return ll\ndef manual_list_comprehension(l): return f(l)", [1,2,3], manual_list_comprehension=[List[int]])
def test_list_comprehension(self):
self.run_test("def list_comprehension(l): return [ x*x for x in l ]", [1,2,3], list_comprehension=[List[int]])
def test_dict_comprehension(self):
self.run_test("def dict_comprehension(l): return { i: 1 for i in l if len(i)>1 }", ["1","12","123"], dict_comprehension=[List[str]])
def test_filtered_list_comprehension(self):
self.run_test("def filtered_list_comprehension(l): return [ x*x for x in l if x > 1 if x <10]", [1,2,3], filtered_list_comprehension=[List[int]])
def test_multilist_comprehension(self):
self.run_test("def multilist_comprehension(l): return [ x*y for x in l for y in l]", [1,2,3], multilist_comprehension=[List[int]])
def test_zipped_list_comprehension(self):
self.run_test("def zipped_list_comprehension(l): return [ x*y for x,y in zip(l,l) ]", [1,2,3], zipped_list_comprehension=[List[int]])
def test_zip(self):
self.run_test("def zip_(l0,l1): return zip(l0,l1)", [1,2,3],["one", "two", "three"], zip_=[List[int], List[str]])
def test_multizip(self):
self.run_test("def multizip(l0,l1): return zip(l0,zip(l0,l1))", [1,2,3],["one", "two", "three"], multizip=[List[int], List[str]])
def test_reduce(self):
self.run_test("def reduce_(l): return reduce(lambda x,y:x+y, l)", [0.,1.1,2.2,3.3], reduce_=[List[float]])
def test_another_reduce(self):
if sys.version_info.major == 2:
code = '''
def another_reduce(l0,l1):
return reduce(lambda x,(y,z):x+y+z, zip(l0, l1),0)
'''
else:
code = '''
def another_reduce(l0,l1):
return reduce(lambda x,y:x+y[0]+y[1], zip(l0, l1),0)
'''
self.run_test(code, [0.4,1.4,2.4,3.4], [0.,1.1,2.2,3.3], another_reduce=[List[float], List[float]])
def test_sum(self):
self.run_test("def sum_(l): return sum(l)", [0.,1.1,2.2,3.3], sum_=[List[float]])
def test_multisum(self):
self.run_test("def multisum(l0, l1): return sum(l0) + sum(l1)", [0.,1.1,2.2,3.3],[1,2,3], multisum=[List[float], List[int]])
def test_max(self):
self.run_test("def max_(l):return max(l)", [ 1.1, 2.2 ], max_=[List[float]])
def test_multimax(self):
self.run_test("def multimax(l,v):return max(v,max(l))", [ 1.1, 2.2 ], 1, multimax=[List[float],int])
def test_min(self):
self.run_test("def min_(l):return min(l)", [ 1.1, 2.2 ], min_=[List[float]])
def test_multimin(self):
self.run_test("def multimin(l,v):return min(v,min(l))", [ 1.1, 2.2 ], 3, multimin=[List[float],int])
@unittest.skipIf(sys.version_info.major == 3, "not supported in pythran3")
def test_map_none(self):
self.run_test("def map_none(l0): return map(None, l0)", [0,1,2], map_none=[List[int]])
@unittest.skipIf(sys.version_info.major == 3, "not supported in pythran3")
def test_map_none2(self):
self.run_test("def map_none2(l0): return map(None, l0, l0)", [0,1,2], map_none2=[List[int]])
def test_map(self):
self.run_test("def map_(l0, l1, v): return list(map(lambda x,y:x*v+y, l0, l1))", [0,1,2], [0.,1.1,2.2], 2, map_=[List[int], List[float], int])
def test_multimap(self):
self.run_test("def multimap(l0, l1, v): return list(map(lambda x,y:x*v+y, l0, map(lambda z:z+1,l1)))", [0,1,2], [0.,1.1,2.2], 2, multimap=[List[int], List[float], int])
def test_intrinsic_map(self):
self.run_test("def intrinsic_map(l): return list(map(max,l))",[[0,1,2],[2,0,1]], intrinsic_map=[List[List[int]]])
def test_range1(self):
self.run_test("def range1_(e): return range(e)", 3, range1_=[int])
def test_range2(self):
self.run_test("def range2_(b,e): return range(b,e)", 1, 3, range2_=[int,int])
def test_range3(self):
self.run_test("def range3_(b,e,s): return range(b,e,s)", 8,3,-2, range3_=[int,int,int])
def test_range4(self):
self.run_test("def range4_(b,e,s): return range(b,e,s)", 8,2,-2, range4_=[int,int,int])
def test_range5(self):
self.run_test("def range5_(b,e,s): return range(b,e,s)", 3,8,1, range5_=[int,int,int])
def test_range6(self):
self.run_test("def range6_(b,e,s): return range(b,e,s)", 3,8,3, range6_=[int,int,int])
def test_range7(self):
self.run_test("def range7_(b,e,s): return range(b,e,s)", 3,9,3, range7_=[int,int,int])
def test_rrange1(self):
self.run_test("def rrange1_(e): return list(reversed(range(e)))", 3, rrange1_=[int])
def test_rrange2(self):
self.run_test("def rrange2_(b,e): return set(reversed(range(b,e)))", 1, 3, rrange2_=[int,int])
def test_rrange3(self):
self.run_test("def rrange3_(b,e,s): return list(reversed(range(b,e,s)))", 8,3,-2, rrange3_=[int,int,int])
def test_rrange4(self):
self.run_test("def rrange4_(b,e,s): return set(reversed(range(b,e,s)))", 8,2,-2, rrange4_=[int,int,int])
def test_rrange5(self):
self.run_test("def rrange5_(b,e,s): return list(reversed(range(b,e,s)))", 3,8,1, rrange5_=[int,int,int])
def test_rrange6(self):
self.run_test("def rrange6_(b,e,s): return set(reversed(range(b,e,s)))", 3,8,3, rrange6_=[int,int,int])
def test_rrange7(self):
self.run_test("def rrange7_(b,e,s): return list(reversed(range(b,e,s)))", 3,9,3, rrange7_=[int,int,int])
def test_multirange(self):
self.run_test("def multirange(i): return list(map(lambda x,y:y*x//2, range(1,i), range(i,1,-1)))", 3, multirange=[int])
def test_xrange1(self):
self.run_test("def xrange1_(e): return list(xrange(e))", 3, xrange1_=[int])
def test_xrange2(self):
self.run_test("def xrange2_(b,e): return list(xrange(b,e))", 1, 3, xrange2_=[int,int])
def test_xrange3(self):
self.run_test("def xrange3_(b,e,s): return list(xrange(b,e,s))", 8,3,-2, xrange3_=[int,int,int])
def test_xrange4(self):
self.run_test("def xrange4_(b,e,s): return list(xrange(b,e,s))", 3,8,1, xrange4_=[int,int,int])
def test_xrange5(self):
self.run_test("def xrange5_(e): return max(xrange(e))", 3, xrange5_=[int])
def test_multixrange(self):
self.run_test("def multixrange(i): return map(lambda x,y:y*x//2, xrange(1,i), xrange(i,1,-1))", 3, multixrange=[int])
def test_print(self):
self.run_test("def print_(a,b,c,d): print(a,b,c,d,'e',1.5)", [1.,2.,3.1],3,True, "d", print_=[List[float], int, bool, str])
def test_print_tuple(self):
self.run_test("def print_tuple(a,b,c,d): t = (a,b,c,d,'e',1.5,); print(t)", [1.,2.,3.1],3,True, "d", print_tuple=[List[float], int, bool, str])
def test_assign(self):
self.run_test("def assign(a): b=2*a ; return b", 1, assign=[int])
def test_multiassign(self):
self.run_test("def multiassign(a):\n c=b=a\n return c", [1], multiassign=[List[int]])
def test_divmax(self):
self.run_test("def divmax_(a): b=4.*a;c=b/2;return max(c,b)", 1, divmax_=[int])
@unittest.skip("impossible to handle max(int, float) without conversion")
def test_divmax_float(self):
self.run_test("def divmax_float_(a): b=2*a;c=b/2;return max(c,b)", 1, divmax_float_=[int])
def test_if(self):
self.run_test("def if_(a,b):\n if a>b: return a\n else: return b", 1, 1.1, if_=[int, float])
def test_while(self):
self.run_test("def while_(a):\n while(a>0): a-=1\n return a", 8, while_=[int])
def test_for(self):
self.run_test("def for_(l):\n s=0\n for i in l:\n s+=i\n return s", [0,1,2], for_=[List[int]])
def test_declarations(self):
code = """
def declarations():
if True:
a=0
while a <3:
b = 1
a = b + a
else:
a=1
return a + b
"""
self.run_test(code, declarations=[])
def test_lambda(self):
code = """
def lambda_():
l=lambda x,y: x+y
return l(1,2) + l(1.2,2)
"""
self.run_test(code, lambda_=[])
def test_multidef1(self):
self.run_test("def def10(): pass\ndef def11(): def10()", def11=[])
def test_multidef2(self):
self.run_test("def def21(): def20()\ndef def20(): pass", def21=[])
def test_multidef3(self):
self.run_test("def def31(): return 1\ndef def30(): return def31()", def31=[])
def test_multidef4(self):
self.run_test("def def41(): return def40()\ndef def40(): return 1", def41=[])
def test_tuple(self):
self.run_test("def tuple_(t): return t[0]+t[1]", (0,1), tuple_=[Tuple[int, int]])
def test_nested_list_comprehension(self):
self.run_test("def nested_list_comprehension(): return [ [ x+y for x in xrange(10) ] for y in xrange(20) ]", nested_list_comprehension=[])
def test_delete(self):
self.run_test("def delete_(v): del v", 1, delete_=[int])
def test_continue(self):
self.run_test("def continue_():\n for i in xrange(3):continue\n return i", continue_=[])
def test_break(self):
self.run_test("def break_():\n for i in xrange(3):break\n return i", break_=[])
def test_assert(self):
self.run_test("def assert_(i): assert i > 0", 1, assert_=[int])
def test_assert_with_msg(self):
self.run_test("def assert_with_msg(i): assert i > 0, 'hell yeah'", 1, assert_with_msg=[int])
def test_import_from(self):
self.run_test("def import_from(): from math import cos ; return cos(1.)", import_from=[])
def test_len(self):
self.run_test("def len_(i,j,k): return len(i)+len(j)+len(k)", "youpi", [1,2],[], len_=[str,List[int], List[float]])
def test_in_string(self):
self.run_test("def in_string(i,j): return i in j", "yo", "youpi", in_string=[str,str])
def test_not_in_string(self):
self.run_test("def not_in_string(i,j): return i not in j", "yo", "youpi", not_in_string=[str,str])
def test_in_list(self):
self.run_test("def in_list(i,j): return i in j", 1, [1,2,3], in_list=[int,List[int]])
def test_not_in_list(self):
self.run_test("def not_in_list(i,j): return i not in j", False, [True, True, True], not_in_list=[bool,List[bool]])
def test_subscript(self):
self.run_test("def subscript(l,i): l[0]=l[0]+l[i]", [1], 0, subscript=[List[int], int])
def test_nested_lists(self):
self.run_test("def nested_lists(l,i): return l[0][i]", [[1]], 0, nested_lists=[List[List[int]],int])
def test_nested_tuples(self):
self.run_test("def nested_tuples(l,i): return l[i][1]", [(0.1,1,)], 0, nested_tuples=[List[Tuple[float,int]],int])
def test_return_empty_list(self):
self.run_test("def return_empty_list(): return list()", return_empty_list=[])
def test_empty_list(self):
self.run_test("def empty_list(): a=[]", empty_list=[])
def test_multi_list(self):
self.run_test("def multi_list(): return [[[2.0],[1,2,3]],[[2.0],[1,2,3]]]", multi_list=[])
def test_empty_tuple(self):
self.run_test("def empty_tuple(): a=()", empty_tuple=[])
def test_multi_tuple(self):
self.run_test("def multi_tuple(): return (1,('e',2.0),[1,2,3])", multi_tuple=[])
def test_augmented_assign0(self):
self.run_test("def augmented_assign0(a):\n a+=1.5\n return a", 12, augmented_assign0=[int])
def test_augmented_assign1(self):
self.run_test("def augmented_assign1(a):\n a-=1.5\n return a", 12, augmented_assign1=[int])
def test_augmented_assign2(self):
self.run_test("def augmented_assign2(a):\n a*=1.5\n return a", 12, augmented_assign2=[int])
def test_augmented_assign3(self):
self.run_test("def augmented_assign3(a):\n a/=1.5\n return a", 12, augmented_assign3=[int])
def test_augmented_assign4(self):
self.run_test("def augmented_assign4(a):\n a %= 5\n return a", 12, augmented_assign4=[int])
def test_augmented_assign5(self):
self.run_test("def augmented_assign5(a):\n a//=2\n return a", 12, augmented_assign5=[int])
def test_augmented_assign6(self):
self.run_test("def augmented_assign6(a):\n a**=5\n return a", 12, augmented_assign6=[int])
def test_augmented_assign7(self):
self.run_test("def augmented_assign7(a):\n a<<=1\n return a", 12, augmented_assign7=[int])
def test_augmented_assign8(self):
self.run_test("def augmented_assign8(a):\n a>>=1\n return a", 12, augmented_assign8=[int])
def test_augmented_assign9(self):
self.run_test("def augmented_assign9(a):\n a^=1\n return a", 12, augmented_assign9=[int])
def test_augmented_assignA(self):
self.run_test("def augmented_assignA(a):\n a|=1\n return a", 12, augmented_assignA=[int])
def test_augmented_assignB(self):
self.run_test("def augmented_assignB(a):\n a&=1\n return a", 12, augmented_assignB=[int])
def test_augmented_list_assign(self):
self.run_test("def augmented_list_assign(l):\n a=list()\n a+=l\n return a", [1,2], augmented_list_assign=[List[int]])
def test_initialization_list(self):
self.run_test("def initialization_list(): return [1, 2.3]", initialization_list=[])
def test_multiple_assign(self):
self.run_test("def multiple_assign():\n a=0 ; b = a\n a=1.5\n return a, b", multiple_assign=[])
def test_multiple_return1(self):
self.run_test("def multiple_return1(a):\n if True:return 1\n else:\n return a", 2, multiple_return1=[int])
def test_multiple_return2(self):
self.run_test("def multiple_return2(a):\n if True:return 1\n else:\n b=a\n return b", 2, multiple_return2=[int])
def test_multiple_return3(self):
self.run_test("def multiple_return3(a):\n if True:return 1\n else:\n b=a\n return a+b", 2, multiple_return3=[int])
def test_id(self):
self.run_test("def id_(a):\n c=a\n return id(a)==id(c)", [1,2,3], id_=[List[int]])
def test_delayed_max(self):
self.run_test("def delayed_max(a,b,c):\n m=max\n return m(a,b) + m(b,c)", 1, 2, 3.5, delayed_max=[int, int, float])
def test_slicing(self):
self.run_test("def slicing(l): return l[0:1] + l[:-1]",[1,2,3,4], slicing=[List[int]])
def test_not_so_deep_recursive_calls(self):
code="""
def a(i): return b(i)
def b(i): return b(a(i-1)) if i else i
def not_so_deep_recursive_calls(i):return b(i)"""
self.run_test(code,3, not_so_deep_recursive_calls=[int])
def test_deep_recursive_calls(self):
code="""
def a(i): return a(i-1) + b(i) if i else i
def b(i): return b(i-1)+a(i-1) if i else c(i-1) if i+1 else i
def c(i): return c(i-1) if i>0 else 1
def deep_recursive_calls(i):a(i)+b(i) +c(i)"""
self.run_test(code,3, deep_recursive_calls=[int])
def test_dummy_nested_def(self):
code="""
def dummy_nested_def(a):
def the_dummy_nested_def(b):return b
return the_dummy_nested_def(a)"""
self.run_test(code,3, dummy_nested_def=[int])
def test_nested_def(self):
code="""
def nested_def(a):
def the_nested_def(b):return a+b
return the_nested_def(3)"""
self.run_test(code,3, nested_def=[int])
def test_none(self):
self.run_test("def none_(l):\n if len(l)==0: return\n else: return l", [], none_=[List[int]])
def test_import(self):
self.run_test("import math\ndef import_(): return math.cos(1)", import_=[])
def test_local_import(self):
self.run_test("def local_import_(): import math;return math.cos(1)", local_import_=[])
def test_abs(self):
""" Check __builtin__.abs behavior with float. """
self.run_test("""
def abs_(a):
return abs(a)""",
-1.3, abs_=[float])
def test_npabs(self):
""" Check __builtin__.abs behavior with numpy.array. """
self.run_test("""
def npabs_(a):
return abs(a)""",
numpy.array([-1.3, 2.3, -4]),
npabs_=[NDArray[float, :]])
def test_all(self):
self.run_test("def all_(a): return all(a)", [True, False, True], all_=[List[bool]])
def test_any(self):
self.run_test("def any_(a): return any(a)", [0, 1, 2], any_=[List[int]])
def test_bin(self):
self.run_test("def bin_(a): return bin(a)", 54321, bin_=[int])
def test_chr(self):
self.run_test("def chr_(a): return chr(a)", 42, chr_=[int])
@unittest.skipIf(sys.version_info.major == 3, "not supported in pythran3")
def test_cmp(self):
self.run_test("def cmp_(a,b): return cmp(a,b)", 1, 4.5, cmp_=[int, float])
def test_complex(self):
self.run_test("def complex_(a): return complex(a)", 1, complex_=[int])
def test_divmod(self):
self.run_test("def divmod_(a,b): return divmod(a,b)", 5, 2, divmod_=[int,int])
def test_enumerate(self):
self.run_test("def enumerate_(l): return [ x for x in enumerate(l) ]", ["a","b","c"], enumerate_=[List[str]])
def test_enumerat2(self):
self.run_test("def enumerate2_(l): return [ x for x in enumerate(l, 3) ]", ["a","b","c"], enumerate2_=[List[str]])
def test_filter(self):
self.run_test("def filter_(l): return filter(lambda x:x%2, l)", [1,2,3], filter_=[List[int]])
def test_hex(self):
self.run_test("def hex_(a): return hex(a)", 18, hex_=[int])
def test_oct(self):
self.run_test("def oct_(a): return oct(a)", 18, oct_=[int])
def test_pow(self):
self.run_test("def pow_(a): return pow(a,5)", 18, pow_=[int])
def test_reversed(self):
self.run_test("def reversed_(l): return [x for x in reversed(l)]", [1,2,3], reversed_=[List[int]])
def test_round(self):
self.run_test("def round_(v): return round(v) + round(v,2)", 0.1234, round_=[float])
def test_sorted0(self):
self.run_test("def sorted0(l): return [x for x in sorted(l)]", [4, 1,2,3], sorted0=[List[int]])
if sys.version_info.major == 3:
def test_sorted1(self):
self.run_test("def sorted1(l): return [x for x in sorted(l, reverse=True)]", [4, 1,2,3], sorted1=[List[int]])
def test_sorted2(self):
self.run_test("def sorted2(l): return [x for x in sorted(l, key=lambda x:-x)]", [4, 1,2,3], sorted2=[List[int]])
def test_sorted3(self):
self.run_test("def sorted3(l): return [x for x in sorted(l,reverse=True,key=lambda x:-x)]", [4, 1,2,3], sorted3=[List[int]])
def test_str(self):
self.run_test("def str_(l): return str(l)", [1,2,3], str_=[List[int]])
def test_append(self):
self.run_test("def append(): l=[] ; l.append(1) ; return l", append=[])
def test_append_in_call(self):
self.run_test("def call(l):l.append(1.)\ndef append_in_call(): l=[] ; call(l) ; l.append(1) ; return l", append_in_call=[])
def test_complex_append_in_call(self):
code="""
def foo(a,b):
i = 3*b
if not i in a:
a.append(i)
def complex_append_in_call(l1,l2):
b = []
for x in l1:
if not x in l2:
foo(b,x)"""
self.run_test(code, [1,2,3],[2],complex_append_in_call=[List[int],List[int]])
def test_complex_number(self):
code="""
def complex_number():
c=complex(0,1)
return c.real + c.imag"""
self.run_test(code, complex_number=[])
def test_raise(self):
self.run_test("def raise_():\n raise RuntimeError('pof')", raise_=[], check_exception=True)
def test_complex_number_serialization(self):
self.run_test("def complex_number_serialization(l): return [x+y for x in l for y in l]", [complex(1,0), complex(1,0)], complex_number_serialization=[List[complex]])
def test_complex_conj(self):
self.run_test("def complex_conjugate(c): return c.conjugate()", complex(0,1), complex_conjugate=[complex])
def test_cast(self):
self.run_test("def cast(i,f): return float(i)+int(f)", 1,1.5, cast=[int, float])
def test_subscript_assignment(self):
code="""
def foo(A):
A[0]=1.5
def subscript_assignment ():
a=range(1)
foo(a)
return a[0]"""
self.run_test(code,subscript_assignment=[])
def test_conflicting_keywords(self):
code="""
def export(template):
return [ new*new for new in template ]"""
self.run_test(code, [1], export=[List[int]])
def test_forelse(self):
code="""
def forelse():
l=0
for i in range(10):
if i > 3:break
for j in range(10):
if j > 5:break
l+=1
else:
l*=2
else:
l*=3
return l"""
self.run_test(code, forelse=[])
def test_tuples(self):
self.run_test("def tuples(n): return ((1,2.,'e') , [ x for x in tuple([1,2,n])] )", 1, tuples=[int])
def test_reversed_slice(self):
self.run_test("def reversed_slice(l): return l[::-2]", [0,1,2,3,4], reversed_slice=[List[int]])
def test_shadow_parameters(self):
code="""
def shadow_parameters(l):
if False:l=None
return l"""
self.run_test(code, [1], shadow_parameters=[List[int]])
def test_yielder(self):
code="""
def iyielder(i):
for k in xrange(i+18):
yield k
return
def yielder():
f=iyielder(1)
b=f.next()
return [i*i for i in f]"""
self.run_test(code, yielder=[])
def test_yield_with_default_param(self):
code="""
def foo(a=1000):
for i in xrange(10):
yield a
def yield_param():
it = foo()
return [i for i in it]"""
self.run_test(code, yield_param=[])
def test_set(self):
code="""
def set_(a,b):
S=set()
S.add(a)
S.add(b)
return len(S)"""
self.run_test(code, 1,2,set_=[int, int])
def test_in_set(self):
code="""
def in_set(a):
S=set()
S.add(a)
return a in S"""
self.run_test(code, 1.5, in_set=[float])
def test_return_set(self):
self.run_test("def return_set(l): return set(l)", [1,2,3,3], return_set=[List[int]])
def test_import_set(self):
self.run_test("def import_set(l): l.add(1) ; return l", {0,2}, import_set=[Set[int]])
def test_raw_set(self):
self.run_test("def raw_set(): return { 1, 1., 2 }", raw_set=[])
def test_iter_set(self):
self.run_test("def iter_set(s):\n l=0\n for k in s: l+=k\n return l", { 1, 2, 3 } , iter_set=[Set[int]])
def test_set_comprehension(self):
self.run_test("def set_comprehension(l): return { i*i for i in l }", [1 , 2, 1, 3], set_comprehension=[List[int]])
def test_slicer(self):
code="""
def slicer(l):
l[2:5]=[1,2]
return l"""
self.run_test(code,[1,2,3,4,5,6,7,8,9], slicer=[List[int]])
def test_generator_expression(self):
code="""
def generator_expression(l):
return sum(x for x in l if x == 1)"""
self.run_test(code,[1,1,1,2], generator_expression=[List[int]])
def test_default_parameters(self):
code="""
def dp(b,a=1.2):
return a
def default_parameters():
a=1
c=dp(a)
d=dp(5,"yeah")
return str(c)+d"""
self.run_test(code, default_parameters=[])
def test_import_as(self):
code="""
from math import cos as COS
def import_as():
x=.42
import math as MATH
return MATH.sin(x)**2 + COS(x)**2"""
self.run_test(code, import_as=[])
def test_tuple_unpacking(self):
self.run_test("def tuple_unpacking(t): a,b = t ; return a, b", (1,"e"), tuple_unpacking=[Tuple[int, str]])
def test_list_unpacking(self):
self.run_test("def list_unpacking(t): [a,b] = t ; return a, b", (1,2), list_unpacking=[Tuple[int, int]])
def test_recursive_attr(self):
self.run_test("def recursive_attr(): return {1,2,3}.union({1,2}).union({5})", recursive_attr=[])
def test_range_negative_step(self):
self.run_test("""def range_negative_step(n):
o=[]
for i in xrange(n, 0, -1): o.append(i)
return o""", 10, range_negative_step=[int])
def test_reversed_range_negative_step(self):
self.run_test("""def reversed_range_negative_step(n):
o=[]
for i in reversed(xrange(n, 0, -1)): o.append(i)
return o""", 10, reversed_range_negative_step=[int])
def test_update_empty_list(self):
self.run_test('''
def update_empty_list(l):
p = list()
return p + l[:1]''', list(range(5)), update_empty_list=[List[int]])
def test_update_list_with_slice(self):
self.run_test('''
def update_list_with_slice(l):
p = list()
for i in xrange(10):
p += l[:1]
return p,i''', list(range(5)), update_list_with_slice=[List[int]])
def test_add_slice_to_list(self):
self.run_test('''
def add_slice_to_list(l):
p = list()
for i in xrange(10):
p = p + l[:1]
return p,i''', list(range(5)), add_slice_to_list=[List[int]])
def test_bool_(self):
self.run_test("def _bool(d): return bool(d)", 3, _bool=[int])
def test_complex_add(self):
self.run_test("def complex_add(): a = 1j ; b = 2 ; return a + b", complex_add=[])
def test_complex_sub(self):
self.run_test("def complex_sub(): a = 1j ; b = 2 ; return a - b", complex_sub=[])
def test_complex_mul(self):
self.run_test("def complex_mul(): a = 1j ; b = 2 ; return a * b", complex_mul=[])
def test_complex_div(self):
self.run_test("def complex_div(): a = 1j ; b = 2 ; return a / b", complex_div=[])
def test_modulo_int0(self):
self.run_test("def modulo_int0(n): return n%3, (-n)%3",
5,
modulo_int0=[int])
def test_modulo_int1(self):
self.run_test("def modulo_int1(n): return n%3, (-n)%3",
3,
modulo_int1=[int])
def test_modulo_float0(self):
self.run_test("def modulo_float0(n): return n%3, (-n)%3",
5.4,
modulo_float0=[float])
def test_modulo_float1(self):
self.run_test("def modulo_float1(n): return n%3, (-n)%3",
3.5,
modulo_float1=[float])
def test_floordiv_int0(self):
self.run_test("def floordiv_int0(n): return n%3, (-n)%3",
5,
floordiv_int0=[int])
def test_floordiv_int1(self):
self.run_test("def floordiv_int1(n): return n//2, (-n)//2",
3,
floordiv_int1=[int])
def test_floordiv_float0(self):
self.run_test("def floordiv_float0(n): return n//2, (-n)//2",
5.4,
floordiv_float0=[float])
def test_floordiv_float1(self):
self.run_test("def floordiv_float1(n): return n//2, (-n)//2",
3.5,
floordiv_float1=[float])
def test_int_base0(self):
self.run_test("def int_base(x, y): return [int(x0, y0) for x0, y0 in zip(x, y)]",
["11", "11", "16", "FF"],
[2, 4, 8, 16],
int_base=[List[str], List[int]])
def test_int_base1(self):
self.run_test("def int_base_lit(x, y): return int(x, 8), int('A', y)",
"14", 16,
int_base_lit=[str, int])
def test_slice0(self):
self.run_test("""
def slice0(a, x):
return a[x], x, slice(1,1,1)""",
numpy.array([-1.3, 2.3, -4]),
slice(0,2,1),
slice0=[NDArray[float, :], slice])
| 37.658537 | 178 | 0.602502 |
b23e6d4e545d26512ac52fab1fbe21332cf2a5d5 | 448 | py | Python | Youcheng/most_common_words.py | xiaoli-chen/Godel | 181b347aa88220b0e3e9ae628089f5acd1e6f170 | [
"Apache-2.0"
]
| null | null | null | Youcheng/most_common_words.py | xiaoli-chen/Godel | 181b347aa88220b0e3e9ae628089f5acd1e6f170 | [
"Apache-2.0"
]
| null | null | null | Youcheng/most_common_words.py | xiaoli-chen/Godel | 181b347aa88220b0e3e9ae628089f5acd1e6f170 | [
"Apache-2.0"
]
| null | null | null | import sys
from collections import Counter
try:
num_words = int(sys.argv[1])
except:
print("usage: most_common_words.py num_words")
sys.exit(1)
counter = Counter(word.lower()
for line in sys.stdin
for word in line.strip().split()
if word)
for word, count in counter.most_common(num_words):
sys.stdout.write(str(count))
sys.stdout.write("\t")
sys.stdout.write(word)
sys.stdout.write("\n")
| 21.333333 | 50 | 0.651786 |
5f80df8b2f6a1306ba4ced7b23038f77a2b9108a | 1,018 | py | Python | apps/auth0login/models.py | Mohitkaushal97/File | 0bc5cca9a557e242861a289af74dfe8b905bc3bd | [
"MIT"
]
| null | null | null | apps/auth0login/models.py | Mohitkaushal97/File | 0bc5cca9a557e242861a289af74dfe8b905bc3bd | [
"MIT"
]
| null | null | null | apps/auth0login/models.py | Mohitkaushal97/File | 0bc5cca9a557e242861a289af74dfe8b905bc3bd | [
"MIT"
]
| null | null | null | from django.db import models
from django.contrib.auth.models import AbstractUser
from django.db.models import CharField
from django.utils.translation import ugettext_lazy as _
# Create your models here.
# from django.contrib.auth.models import User
class User(AbstractUser):
# See fields: https://docs.djangoproject.com/en/3.0/ref/contrib/auth/
# https://simpleisbetterthancomplex.com/tutorial/2016/07/22/how-to-extend-django-user-model.html#abstractuser
first_name = CharField(_("First Name of the User"), blank=True, max_length=150)
last_name = CharField(_("Last Name of the User"), blank=True, max_length=150)
email = CharField(_("Email Address of the User"), blank=True, max_length=150)
# THIS IS NOT GOOD! As it created migration code in local Python package!!!
# e.g.:
# C:\Users\username\AppData\Roaming\Python\Python37\site-packages\django\contrib\auth\migrations\0012_auto_20200805_1355.py
# field = User._meta.get_field('first_name')
# field.max_length = 254
| 42.416667 | 124 | 0.749509 |
7667bd27d5d686a250330875b5578144581681e9 | 4,336 | py | Python | verellen/retailers/views.py | bitblueprint/verellen.biz | f9b26f783f94518314b12e360b0b297b08ad85c0 | [
"MIT"
]
| null | null | null | verellen/retailers/views.py | bitblueprint/verellen.biz | f9b26f783f94518314b12e360b0b297b08ad85c0 | [
"MIT"
]
| null | null | null | verellen/retailers/views.py | bitblueprint/verellen.biz | f9b26f783f94518314b12e360b0b297b08ad85c0 | [
"MIT"
]
| null | null | null | from django.shortcuts import render, redirect
from django.db.models import Q
import re
from retailers.models import Retailer
def home(request):
all = Retailer.objects.all()
matches = all
showing_all = True
query = ""
boutiques = Retailer.objects.filter(partner__is_boutique=True)
if 'query' in request.GET.keys():
showing_all = False
query = request.GET['query']
if len(query) == 2:
matches = Retailer.objects.filter(Q(state__icontains=query))
else:
matchObj = re.match(r'(.{2}),?\s+(USA|Canada)', query, flags=re.IGNORECASE)
if matchObj:
matches = Retailer.objects.filter(Q(state__icontains=matchObj.group(1)) & Q(country__icontains=matchObj.group(2)))
if len(matches) == len(all) or len(matches) == 0:
split = query.split(',')
array = []
for s in split:
s = s.replace(',', '').strip()
if len(s) > 1 and not s.isdigit():
array.append(s)
if len(array) > 1:
regex = '^.*(%s).*$' % '|'.join(array)
matches = Retailer.objects.filter(Q(partner__name__icontains=query)
| Q(address__icontains=query)
| Q(city__icontains=query)
| Q(phone__icontains=query)
| Q(state__icontains=query)
| Q(country__icontains=query)
| Q(zip_code__icontains=query)
| Q(localities__icontains=query)
| Q(partner__name__iregex=regex)
| Q(address__iregex=regex)
| Q(city__iregex=regex)
| Q(phone__iregex=regex)
| Q(state__iregex=regex)
| Q(zip_code__iregex=regex)
| Q(localities__iregex=regex)
)
else:
matches = Retailer.objects.filter(Q(partner__name__icontains=query)
| Q(address__icontains=query)
| Q(city__icontains=query)
| Q(phone__icontains=query)
| Q(state__icontains=query)
| Q(country__icontains=query)
| Q(zip_code__icontains=query)
| Q(localities__icontains=query)
)
# If it is the case there are no matches we try to do a more greedy search by splitting the query even more
if len(matches) < 1:
split = re.findall(r'[,\w]+', query)
array = []
for s in split:
s = s.replace(',', '').strip()
if len(s) > 2 and not s.isdigit():
array.append(s)
if array and len(array) > 0:
regex = '^.*(%s).*$' % '|'.join(array)
matches = Retailer.objects.filter(Q(partner__name__iregex=regex)
| Q(address__iregex=regex)
| Q(city__iregex=regex)
| Q(phone__iregex=regex)
| Q(state__iregex=regex)
| Q(zip_code__iregex=regex)
| Q(localities__iregex=regex)
)
matches = matches.order_by('partner__name')
return render(request, 'retailers/home.html', {
'matches': matches,
'retailers': matches,
'search_query': query,
'showing_all': showing_all,
'boutiques': boutiques
})
| 48.719101 | 130 | 0.411439 |
176daf48afeb4fdcde520342fb501399fcff4f24 | 4,181 | py | Python | Generalized 'Monty Hall' Problem Simulation .py | tameemalaa/General-Monty-Hall-Problem-Simulation | 63c98bb235bb1de527936310bfb9e3f231668ad0 | [
"MIT"
]
| 2 | 2021-07-24T04:25:47.000Z | 2021-07-24T17:07:16.000Z | Generalized 'Monty Hall' Problem Simulation .py | tameemalaa/Generalized-Monty-Hall-Problem-Simulation | 63c98bb235bb1de527936310bfb9e3f231668ad0 | [
"MIT"
]
| null | null | null | Generalized 'Monty Hall' Problem Simulation .py | tameemalaa/Generalized-Monty-Hall-Problem-Simulation | 63c98bb235bb1de527936310bfb9e3f231668ad0 | [
"MIT"
]
| null | null | null | from math import floor
from random import choice
import matplotlib.pyplot as plt
from prettytable import PrettyTable
class door :
def __init__(self):
self.status=True
self.hascar=False
def play(num_doors = 3, num_cars=1 , num_opened= 1):
doors = [door() for i in range (num_doors)]
i = 0
while i < num_cars:
change = choice(doors)
if not(change.hascar) :
setattr(change , 'hascar', True)
i += 1
pick = choice(doors)
i = 0
while i < num_opened :
change = choice(doors)
if change.status and not(change.hascar) and pick is not change :
setattr(change, 'status', False)
i += 1
while True :
switch = choice(doors)
if switch.status and switch is not pick :
break
while True :
ran = choice(doors)
if ran.status:
break
return [pick.hascar ,switch.hascar, ran.hascar ]
def main() :
print (" Please note: Any invaild input will set to the default value!!!")
while True :
trials = int(input("How many times to play? (Defualt= 10000) ") or "10000")
num_doors = int(input("Choose the total number of doors? (Defualt= 3) ") or "3")
num_cars = int(input("Choose the number of cars? (Defualt= 1) ") or "1")
num_opened = int(input("Choose the number of doors for monty to open? (Defualt= 1) ") or "1")
wins_pick, wins_switch,wins_random = 0,0,0
if num_doors > (num_opened+1) and num_cars < num_doors -num_opened and num_doors>= 3 and num_cars >=1 and num_opened>=1 and trials >=1 :
break
else :
print(""" The game conditions does not fit, please follow the following rules:
1- Number of doors opened should be less than the total number of doors by 2 , one for the first pick and at least one for the second stage.
2- the number of cars should be less than the number of total doors - the number of doors will be opened.
3- the minmun number of each game condition is its default value.
4- the minmum number of trials is 1. """)
switch_theo = (num_cars*(num_doors-1)) / (num_doors*(num_doors - 1 - num_opened))*100
pick_perc , switch_perc , random_perc , x = [0], [0], [0], [0]
for i in range (1 , trials+1 ):
lst = play(num_doors,num_cars,num_opened)
wins_pick += lst[0]
wins_switch += lst[1]
wins_random += lst[2]
if i % (floor(trials/1000))==0 or i == trials or trials<1000 :
x.append(i)
pick_perc.append((wins_pick/i)*100)
switch_perc.append((wins_switch/i)*100)
random_perc.append((wins_random/i)*100)
if i % 1000 == 0 or i == 1 or i == trials :
plt.cla()
plt.ion
plt.title("Monty Hall Simulation", fontsize=20)
plt.xlabel("Trials")
plt.ylabel("Win Percentage %")
plt.axis([0, trials, 0, 100])
plt.plot(x,pick_perc,color='Red',label='Stay' )
plt.plot(x,switch_perc,color='Blue',label='Switch')
plt.plot(x,random_perc, color='Green',label='Random')
plt.legend(loc='upper right', title='Strategy')
plt.grid()
plt.pause(0.00000000000000000000000000000000000000000000000000000000000000000000000001)
print(f"The simulation results in {trials} trials: ")
t1 = PrettyTable()
t1.add_column("Strategy",["Stay ","Switch ","Random "])
t1.add_column("Win Percentage % ",[pick_perc[-1],switch_perc[-1],random_perc[-1]])
t2 = PrettyTable()
t2.add_column("Theoretical Switch Win Percentage % ",[switch_theo])
t2.add_column("Simulation Switch Win Percentage % ",[switch_perc[-1]])
print(t1)
print(t2)
plt.show()
while True :
main ()
while True :
i= input("Type 1 to run another simulation or 2 to terminate: ")
if i == "1" :
breaker = False
break
elif i == "2":
breaker= True
break
else :
print(" Please, enter 1 or 2 ")
if breaker:
break
| 41.39604 | 152 | 0.58718 |
643a13731e8ae0e8dc5ca500748a37ec2d44ea51 | 851 | py | Python | apps/api/registration/serializers.py | Failjak/constructCompany_DRF | 458a8e33d7bca72db883745388065a05c42bbd1f | [
"BSD-3-Clause"
]
| null | null | null | apps/api/registration/serializers.py | Failjak/constructCompany_DRF | 458a8e33d7bca72db883745388065a05c42bbd1f | [
"BSD-3-Clause"
]
| null | null | null | apps/api/registration/serializers.py | Failjak/constructCompany_DRF | 458a8e33d7bca72db883745388065a05c42bbd1f | [
"BSD-3-Clause"
]
| null | null | null | from rest_framework import serializers
from rest_framework_simplejwt.tokens import RefreshToken, AccessToken
from django.contrib.auth import get_user_model
UserModel = get_user_model()
class UserSerializer(serializers.ModelSerializer):
"""Serializer for creating user objects."""
password = serializers.CharField(write_only=True)
def create(self, validated_data):
user = UserModel.objects.create_user(
username=validated_data['username'],
password=validated_data['password'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name'],
)
return user
class Meta:
model = UserModel
fields = (
'id',
'username',
'password',
"first_name",
"last_name",
)
| 25.029412 | 69 | 0.635723 |
fc156ec457d51a315b92d549de5a63e6cbff78df | 7,570 | py | Python | sdk/python/pulumi_azure_native/web/v20180201/get_web_app_deployment_slot.py | sebtelko/pulumi-azure-native | 711ec021b5c73da05611c56c8a35adb0ce3244e4 | [
"Apache-2.0"
]
| null | null | null | sdk/python/pulumi_azure_native/web/v20180201/get_web_app_deployment_slot.py | sebtelko/pulumi-azure-native | 711ec021b5c73da05611c56c8a35adb0ce3244e4 | [
"Apache-2.0"
]
| null | null | null | sdk/python/pulumi_azure_native/web/v20180201/get_web_app_deployment_slot.py | sebtelko/pulumi-azure-native | 711ec021b5c73da05611c56c8a35adb0ce3244e4 | [
"Apache-2.0"
]
| null | null | null | # 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__ = [
'GetWebAppDeploymentSlotResult',
'AwaitableGetWebAppDeploymentSlotResult',
'get_web_app_deployment_slot',
]
@pulumi.output_type
class GetWebAppDeploymentSlotResult:
"""
User credentials used for publishing activity.
"""
def __init__(__self__, active=None, author=None, author_email=None, deployer=None, details=None, end_time=None, id=None, kind=None, message=None, name=None, start_time=None, status=None, type=None):
if active and not isinstance(active, bool):
raise TypeError("Expected argument 'active' to be a bool")
pulumi.set(__self__, "active", active)
if author and not isinstance(author, str):
raise TypeError("Expected argument 'author' to be a str")
pulumi.set(__self__, "author", author)
if author_email and not isinstance(author_email, str):
raise TypeError("Expected argument 'author_email' to be a str")
pulumi.set(__self__, "author_email", author_email)
if deployer and not isinstance(deployer, str):
raise TypeError("Expected argument 'deployer' to be a str")
pulumi.set(__self__, "deployer", deployer)
if details and not isinstance(details, str):
raise TypeError("Expected argument 'details' to be a str")
pulumi.set(__self__, "details", details)
if end_time and not isinstance(end_time, str):
raise TypeError("Expected argument 'end_time' to be a str")
pulumi.set(__self__, "end_time", end_time)
if id and not isinstance(id, str):
raise TypeError("Expected argument 'id' to be a str")
pulumi.set(__self__, "id", id)
if kind and not isinstance(kind, str):
raise TypeError("Expected argument 'kind' to be a str")
pulumi.set(__self__, "kind", kind)
if message and not isinstance(message, str):
raise TypeError("Expected argument 'message' to be a str")
pulumi.set(__self__, "message", message)
if name and not isinstance(name, str):
raise TypeError("Expected argument 'name' to be a str")
pulumi.set(__self__, "name", name)
if start_time and not isinstance(start_time, str):
raise TypeError("Expected argument 'start_time' to be a str")
pulumi.set(__self__, "start_time", start_time)
if status and not isinstance(status, int):
raise TypeError("Expected argument 'status' to be a int")
pulumi.set(__self__, "status", status)
if type and not isinstance(type, str):
raise TypeError("Expected argument 'type' to be a str")
pulumi.set(__self__, "type", type)
@property
@pulumi.getter
def active(self) -> Optional[bool]:
"""
True if deployment is currently active, false if completed and null if not started.
"""
return pulumi.get(self, "active")
@property
@pulumi.getter
def author(self) -> Optional[str]:
"""
Who authored the deployment.
"""
return pulumi.get(self, "author")
@property
@pulumi.getter(name="authorEmail")
def author_email(self) -> Optional[str]:
"""
Author email.
"""
return pulumi.get(self, "author_email")
@property
@pulumi.getter
def deployer(self) -> Optional[str]:
"""
Who performed the deployment.
"""
return pulumi.get(self, "deployer")
@property
@pulumi.getter
def details(self) -> Optional[str]:
"""
Details on deployment.
"""
return pulumi.get(self, "details")
@property
@pulumi.getter(name="endTime")
def end_time(self) -> Optional[str]:
"""
End time.
"""
return pulumi.get(self, "end_time")
@property
@pulumi.getter
def id(self) -> str:
"""
Resource Id.
"""
return pulumi.get(self, "id")
@property
@pulumi.getter
def kind(self) -> Optional[str]:
"""
Kind of resource.
"""
return pulumi.get(self, "kind")
@property
@pulumi.getter
def message(self) -> Optional[str]:
"""
Details about deployment status.
"""
return pulumi.get(self, "message")
@property
@pulumi.getter
def name(self) -> str:
"""
Resource Name.
"""
return pulumi.get(self, "name")
@property
@pulumi.getter(name="startTime")
def start_time(self) -> Optional[str]:
"""
Start time.
"""
return pulumi.get(self, "start_time")
@property
@pulumi.getter
def status(self) -> Optional[int]:
"""
Deployment status.
"""
return pulumi.get(self, "status")
@property
@pulumi.getter
def type(self) -> str:
"""
Resource type.
"""
return pulumi.get(self, "type")
class AwaitableGetWebAppDeploymentSlotResult(GetWebAppDeploymentSlotResult):
# pylint: disable=using-constant-test
def __await__(self):
if False:
yield self
return GetWebAppDeploymentSlotResult(
active=self.active,
author=self.author,
author_email=self.author_email,
deployer=self.deployer,
details=self.details,
end_time=self.end_time,
id=self.id,
kind=self.kind,
message=self.message,
name=self.name,
start_time=self.start_time,
status=self.status,
type=self.type)
def get_web_app_deployment_slot(id: Optional[str] = None,
name: Optional[str] = None,
resource_group_name: Optional[str] = None,
slot: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetWebAppDeploymentSlotResult:
"""
User credentials used for publishing activity.
:param str id: Deployment ID.
:param str name: Name of the app.
:param str resource_group_name: Name of the resource group to which the resource belongs.
:param str slot: Name of the deployment slot. If a slot is not specified, the API gets a deployment for the production slot.
"""
__args__ = dict()
__args__['id'] = id
__args__['name'] = name
__args__['resourceGroupName'] = resource_group_name
__args__['slot'] = slot
if opts is None:
opts = pulumi.InvokeOptions()
if opts.version is None:
opts.version = _utilities.get_version()
__ret__ = pulumi.runtime.invoke('azure-native:web/v20180201:getWebAppDeploymentSlot', __args__, opts=opts, typ=GetWebAppDeploymentSlotResult).value
return AwaitableGetWebAppDeploymentSlotResult(
active=__ret__.active,
author=__ret__.author,
author_email=__ret__.author_email,
deployer=__ret__.deployer,
details=__ret__.details,
end_time=__ret__.end_time,
id=__ret__.id,
kind=__ret__.kind,
message=__ret__.message,
name=__ret__.name,
start_time=__ret__.start_time,
status=__ret__.status,
type=__ret__.type)
| 33.201754 | 202 | 0.610832 |
0d40aa68476092dd0241c88acb0af1f688de8058 | 569 | py | Python | rollyourown/seo/__init__.py | Arvada13/SEO-Marketing-Reseller-White-Label-Hosting | 2a088f53c8c04b423072a78d7a0b9db48c6ea8c8 | [
"BSD-3-Clause"
]
| 137 | 2015-01-15T04:53:39.000Z | 2022-02-14T06:04:32.000Z | rollyourown/seo/__init__.py | Arvada13/SEO-Marketing-Reseller-White-Label-Hosting | 2a088f53c8c04b423072a78d7a0b9db48c6ea8c8 | [
"BSD-3-Clause"
]
| 14 | 2015-02-23T20:13:57.000Z | 2017-07-05T13:59:47.000Z | rollyourown/seo/__init__.py | Arvada13/SEO-Marketing-Reseller-White-Label-Hosting | 2a088f53c8c04b423072a78d7a0b9db48c6ea8c8 | [
"BSD-3-Clause"
]
| 69 | 2015-01-04T14:00:35.000Z | 2022-03-01T14:12:00.000Z | VERSION = (1, 0, 0, 'beta', 1)
__authors__ = ["Will Hardy <[email protected]>"]
from rollyourown.seo.base import Metadata, Tag, KeywordTag, MetaTag, Raw, Literal, get_metadata, get_linked_metadata
def get_version():
version = '%s.%s' % (VERSION[0], VERSION[1])
if VERSION[2]:
version = '%s.%s' % (version, VERSION[2])
if VERSION[3:] == ('alpha', 0):
version = '%s pre-alpha' % version
elif VERSION[3] != 'final':
version = '%s %s %s' % (version, VERSION[3], VERSION[4])
return version
__version__ = get_version()
| 35.5625 | 116 | 0.618629 |
ca3ad1d76446cab073bda27095ee14bb7e3f6f54 | 1,687 | py | Python | hb_quant/huobi/model/account/account_update.py | wenli135/Binance-volatility-trading-bot | 75a03ad61df0e95492128fb6f1f419d4dc256ab3 | [
"MIT"
]
| 611 | 2019-07-10T08:17:50.000Z | 2022-03-21T18:56:39.000Z | hb_quant/huobi/model/account/account_update.py | wenli135/Binance-volatility-trading-bot | 75a03ad61df0e95492128fb6f1f419d4dc256ab3 | [
"MIT"
]
| 105 | 2019-07-12T03:43:41.000Z | 2022-03-30T10:33:06.000Z | hb_quant/huobi/model/account/account_update.py | wenli135/Binance-volatility-trading-bot | 75a03ad61df0e95492128fb6f1f419d4dc256ab3 | [
"MIT"
]
| 325 | 2019-07-12T02:46:54.000Z | 2022-03-21T18:56:41.000Z | from huobi.constant import *
class AccountUpdate:
"""
The account change information received by subscription of account.
:member
currency: The currency of the change.
accountId: The account id.
balance: Account balance (only exists when account balance changed)
available: Available balance (only exists when available balance changed)
changeType: Change type see AccountChangeType, valid value: order-place,order-match,order-refund,order-cancel,order-fee-refund,margin-transfer,margin-loan,margin-interest,margin-repay,other,
accountType: Account type see AccountBalanceUpdateType, valid value: trade, frozen, loan, interest
changeTime: Change time, unix time in millisecond
"""
def __init__(self):
self.currency = ""
self.accountId = 0
self.balance = ""
self.available = ""
self.changeType = AccountChangeType.INVALID
self.accountType = AccountBalanceUpdateType.INVALID
self.changeTime = 0
def print_object(self, format_data=""):
from huobi.utils.print_mix_object import PrintBasic
PrintBasic.print_basic(self.currency, format_data + "Currency")
PrintBasic.print_basic(self.accountId, format_data + "Account ID")
PrintBasic.print_basic(self.balance, format_data + "Balance")
PrintBasic.print_basic(self.available, format_data + "Available")
PrintBasic.print_basic(self.changeType, format_data + "Account Change Type")
PrintBasic.print_basic(self.accountType, format_data + "Account Balance Change Type")
PrintBasic.print_basic(self.changeTime, format_data + "Account Timestamp")
| 46.861111 | 198 | 0.7131 |
124b340722a2beeb1d46622fb5139cec3a4d9667 | 92 | py | Python | Codeforces/240/gen.py | Mindjolt2406/Competitive-Programming | d000d98bf7005ee4fb809bcea2f110e4c4793b80 | [
"MIT"
]
| 2 | 2018-12-11T14:37:24.000Z | 2022-01-23T18:11:54.000Z | Codeforces/240/gen.py | Mindjolt2406/Competitive-Programming | d000d98bf7005ee4fb809bcea2f110e4c4793b80 | [
"MIT"
]
| null | null | null | Codeforces/240/gen.py | Mindjolt2406/Competitive-Programming | d000d98bf7005ee4fb809bcea2f110e4c4793b80 | [
"MIT"
]
| null | null | null | from random import *
print 20
for i in range(2**20): print randint(1,100),
print ""
print 0 | 15.333333 | 44 | 0.695652 |
e72774f091e49dd4ccf0fc704ad3d23d5076d816 | 11,538 | py | Python | test/hummingbot/core/web_assistant/connections/test_ws_connection.py | BGTCapital/hummingbot | 2c50f50d67cedccf0ef4d8e3f4c8cdce3dc87242 | [
"Apache-2.0"
]
| 542 | 2021-12-17T22:34:31.000Z | 2022-03-31T14:36:23.000Z | test/hummingbot/core/web_assistant/connections/test_ws_connection.py | BGTCapital/hummingbot | 2c50f50d67cedccf0ef4d8e3f4c8cdce3dc87242 | [
"Apache-2.0"
]
| 291 | 2021-12-17T20:07:53.000Z | 2022-03-31T11:07:23.000Z | test/hummingbot/core/web_assistant/connections/test_ws_connection.py | BGTCapital/hummingbot | 2c50f50d67cedccf0ef4d8e3f4c8cdce3dc87242 | [
"Apache-2.0"
]
| 220 | 2021-12-17T12:41:23.000Z | 2022-03-31T23:03:22.000Z | import asyncio
import json
import unittest
from typing import Awaitable, List
from unittest.mock import AsyncMock, patch
import aiohttp
from hummingbot.core.web_assistant.connections.ws_connection import WSConnection
from hummingbot.core.web_assistant.connections.data_types import WSRequest, WSResponse
from test.hummingbot.connector.network_mocking_assistant import (
NetworkMockingAssistant
)
class WSConnectionTest(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
super().setUpClass()
cls.ev_loop = asyncio.get_event_loop()
cls.ws_url = "ws://some/url"
def setUp(self) -> None:
super().setUp()
self.mocking_assistant = NetworkMockingAssistant()
self.client_session = aiohttp.ClientSession()
self.ws_connection = WSConnection(self.client_session)
self.async_tasks: List[asyncio.Task] = []
def tearDown(self) -> None:
self.ws_connection.disconnect()
self.client_session.close()
for task in self.async_tasks:
task.cancel()
super().tearDown()
def async_run_with_timeout(self, coroutine: Awaitable, timeout: int = 1):
ret = self.ev_loop.run_until_complete(asyncio.wait_for(coroutine, timeout))
return ret
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_connect_and_disconnect(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.assertFalse(self.ws_connection.connected)
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.assertTrue(self.ws_connection.connected)
self.async_run_with_timeout(self.ws_connection.disconnect())
self.assertFalse(self.ws_connection.connected)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_attempt_to_connect_second_time_raises(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
with self.assertRaises(RuntimeError) as e:
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.assertEqual("WS is connected.", str(e.exception))
def test_send_when_disconnected_raises(self):
request = WSRequest(payload={"one": 1})
with self.assertRaises(RuntimeError) as e:
self.async_run_with_timeout(self.ws_connection.send(request))
self.assertEqual("WS is not connected.", str(e.exception))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_send(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
request = WSRequest(payload={"one": 1})
self.async_run_with_timeout(self.ws_connection.send(request))
json_msgs = self.mocking_assistant.json_messages_sent_through_websocket(
ws_connect_mock.return_value
)
self.assertEqual(1, len(json_msgs))
self.assertEqual(request.payload, json_msgs[0])
def test_receive_when_disconnected_raises(self):
with self.assertRaises(RuntimeError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual("WS is not connected.", str(e.exception))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_raises_on_timeout(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
def raise_timeout(*_, **__):
raise asyncio.TimeoutError
ws_connect_mock.return_value.receive.side_effect = raise_timeout
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
with self.assertRaises(asyncio.TimeoutError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual("Message receive timed out.", str(e.exception))
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
data = {"one": 1}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(data)
)
self.assertEqual(0, self.ws_connection.last_recv_time)
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertIsInstance(response, WSResponse)
self.assertEqual(data, response.data)
self.assertNotEqual(0, self.ws_connection.last_recv_time)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_disconnects_and_raises_on_aiohttp_closed(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
ws_connect_mock.return_value.close_code = 1111
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.CLOSED
)
with self.assertRaises(ConnectionError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual("The WS connection was closed unexpectedly. Close code = 1111 msg data: ", str(e.exception))
self.assertFalse(self.ws_connection.connected)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_disconnects_and_raises_on_aiohttp_close(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
ws_connect_mock.return_value.close_code = 1111
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.CLOSE
)
with self.assertRaises(ConnectionError) as e:
self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual("The WS connection was closed unexpectedly. Close code = 1111 msg data: ", str(e.exception))
self.assertFalse(self.ws_connection.connected)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ignores_aiohttp_close_msg_if_disconnect_called(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.CLOSED
)
prev_side_effect = ws_connect_mock.return_value.receive.side_effect
async def disconnect_on_side_effect(*args, **kwargs):
await self.ws_connection.disconnect()
return await prev_side_effect(*args, **kwargs)
ws_connect_mock.return_value.receive.side_effect = disconnect_on_side_effect
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertFalse(self.ws_connection.connected)
self.assertIsNone(response)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ignores_ping(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.PING
)
data = {"one": 1}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(data)
)
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual(data, response.data)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_sends_pong_on_ping(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.PING
)
receive_task = self.ev_loop.create_task(self.ws_connection.receive())
self.async_tasks.append(receive_task)
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
ws_connect_mock.return_value.pong.assert_called()
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ping_updates_last_recv_time(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.PING
)
receive_task = self.ev_loop.create_task(self.ws_connection.receive())
self.async_tasks.append(receive_task)
self.assertEqual(0, self.ws_connection.last_recv_time)
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertNotEqual(0, self.ws_connection.last_recv_time)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_ignores_pong(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.PONG
)
data = {"one": 1}
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message=json.dumps(data)
)
response = self.async_run_with_timeout(self.ws_connection.receive())
self.assertEqual(data, response.data)
@patch("aiohttp.client.ClientSession.ws_connect", new_callable=AsyncMock)
def test_receive_pong_updates_last_recv_time(self, ws_connect_mock):
ws_connect_mock.return_value = self.mocking_assistant.create_websocket_mock()
self.async_run_with_timeout(self.ws_connection.connect(self.ws_url))
self.mocking_assistant.add_websocket_aiohttp_message(
ws_connect_mock.return_value, message="", message_type=aiohttp.WSMsgType.PONG
)
receive_task = self.ev_loop.create_task(self.ws_connection.receive())
self.async_tasks.append(receive_task)
self.assertEqual(0, self.ws_connection.last_recv_time)
self.mocking_assistant.run_until_all_aiohttp_messages_delivered(ws_connect_mock.return_value)
self.assertNotEqual(0, self.ws_connection.last_recv_time)
| 45.604743 | 117 | 0.744583 |
375775783257a261414f75f3fb58b3b78bf7fe51 | 393 | py | Python | app/models.py | luucasaraujoo/devops-ac08 | c57617ca6d716e9858ef22df2268b98420628eeb | [
"MIT"
]
| null | null | null | app/models.py | luucasaraujoo/devops-ac08 | c57617ca6d716e9858ef22df2268b98420628eeb | [
"MIT"
]
| 28 | 2018-10-25T00:42:21.000Z | 2018-10-26T23:19:19.000Z | app/models.py | luucasaraujoo/devops-ac08 | c57617ca6d716e9858ef22df2268b98420628eeb | [
"MIT"
]
| null | null | null | from django.db import models
# Create your models here.
class Curso(models.Model):
nome = models.CharField(max_length=200)
periodo = models.CharField(max_length=50)
instituicao = models.CharField(max_length=200)
class Vestibular(models.Model):
nome = models.CharField(max_length=200)
class Inscritos(models.Model):
nome = models.CharField(max_length=200)
| 21.833333 | 50 | 0.725191 |
eba76c22292a1fc47eb7324c4300630b8a6eb41c | 1,540 | py | Python | Dodgeball/Dodgeball2.py | Software-Cat/Python-Mini-Projects | 3e8a150758eddfc2b21a5e8c665fd6eca850e55d | [
"MIT"
]
| null | null | null | Dodgeball/Dodgeball2.py | Software-Cat/Python-Mini-Projects | 3e8a150758eddfc2b21a5e8c665fd6eca850e55d | [
"MIT"
]
| null | null | null | Dodgeball/Dodgeball2.py | Software-Cat/Python-Mini-Projects | 3e8a150758eddfc2b21a5e8c665fd6eca850e55d | [
"MIT"
]
| null | null | null | import pygame
import sys
def vertical_dashed_line(screen, color, startPos, length, width, dashLength):
segments = []
dashes = int(length/dashLength)
startY = startPos[1]
for i in range(dashes):
if i%2 == 0:
segments.append([[startPos[0], startY+i*dashLength], [startPos[0], startY+(i+1)*dashLength]])
for segment in segments:
pygame.draw.line(screen, color, segment[0], segment[1], width)
def game_over():
pass
def pause():
pass
def draw_stage():
# Ground
pygame.draw.rect(screen, [200, 200, 200], [0, 0, 1105, 697])
pygame.draw.rect(screen, [0, 0, 0], [0, 0, 1105, 697], 2)
# Court
pygame.draw.rect(screen, [230, 230, 230], [42.5, 93.5, 1020, 510])
# Neutral Zone
pygame.draw.rect(screen, [190, 190, 190], [518.5, 93.5, 68, 510], 0)
# Court lines
# Centerline
pygame.draw.line(screen, [0, 0, 0], [552.5, 93.5], [552.5, 603.5])
# Neutral lines
vertical_dashed_line(screen, [0, 0, 0], [518.5, 93.5], 510, 1, 12)
#pygame.draw.line(screen, [0, 0, 0], [518.5, 93.5], [518.5, 603.5])
pygame.draw.line(screen, [0, 0, 0], [586.5, 93.5], [586.5, 603.5])
# Court border accent
pygame.draw.rect(screen, [0, 0, 0], [42.5, 93.5, 1020, 510], 5)
pygame.init()
screen = pygame.display.set_mode([1105, 697])
# Coefficient = 17
running = True
while running:
draw_stage()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pygame.display.flip()
game_over()
| 25.245902 | 105 | 0.597403 |
a899aa019ae04c0d57546c200c2faaa07cd18e3e | 2,648 | py | Python | SmartObjectFramework/ObjectService/rdflib/plugins/serializers/trig.py | OSIOT/OBSOLETE-IoT-Toolkit | f6cfb116a9f115d5ce288d990b57e0f6855283cc | [
"Apache-2.0"
]
| 1 | 2019-06-12T19:37:58.000Z | 2019-06-12T19:37:58.000Z | SmartObjectFramework/ObjectService/rdflib/plugins/serializers/trig.py | OSIOT/OBSOLETE-IoT-Toolkit | f6cfb116a9f115d5ce288d990b57e0f6855283cc | [
"Apache-2.0"
]
| null | null | null | SmartObjectFramework/ObjectService/rdflib/plugins/serializers/trig.py | OSIOT/OBSOLETE-IoT-Toolkit | f6cfb116a9f115d5ce288d990b57e0f6855283cc | [
"Apache-2.0"
]
| null | null | null | """
Trig RDF graph serializer for RDFLib.
See <http://www.w3.org/2010/01/Trig/Trig> for syntax specification.
"""
from rdflib.plugins.serializers.turtle import TurtleSerializer
from rdflib.plugins.serializers.turtle import _GEN_QNAME_FOR_DT
from rdflib.plugins.serializers.turtle import VERB
from rdflib.term import BNode, Literal
from rdflib.compat import defaultdict
__all__ = ['TrigSerializer']
class TrigSerializer(TurtleSerializer):
short_name = "trig"
indentString = 4 * u' '
def __init__(self, store):
if store.context_aware:
self.contexts = store.contexts()
else:
self.contexts = [store]
super(TrigSerializer, self).__init__(store)
def preprocess(self):
for context in self.contexts:
for triple in context:
self.preprocessTriple(triple, context.identifier)
def preprocessTriple(self, triple, identifier):
s, p, o = triple
references = self.refCount(o) + 1
self._references[o] = references
self._subjects[s] = True
self._contexts[identifier].add(s)
for i, node in enumerate(triple):
if node in self.keywords:
continue
# Don't use generated prefixes for subjects and objects
self.getQName(node, gen_prefix=(i == VERB))
if isinstance(node, Literal) and node.datatype:
self.getQName(node.datatype, gen_prefix=_GEN_QNAME_FOR_DT)
p = triple[1]
if isinstance(p, BNode):
self._references[p] = self.refCount(p) + 1
def reset(self):
super(TrigSerializer, self).reset()
self._contexts = defaultdict(set)
def serialize(self, stream, base=None, encoding=None, spacious=None, **args):
self.reset()
self.stream = stream
self.base = base
if spacious is not None:
self._spacious = spacious
self.preprocess()
# @@FIXME: Unused code ...
# subjects_list = self.orderSubjects()
self.startDocument()
firstTime = True
for identifier, subjects in self._contexts.items():
self.write(self.indent() + '\n<%s> = {' % identifier)
self.depth += 1
for subject in subjects:
if self.isDone(subject):
continue
if firstTime:
firstTime = False
if self.statement(subject) and not firstTime:
self.write('\n')
self.depth -= 1
self.write('}\n')
self.endDocument()
stream.write(u"\n".encode('ascii'))
| 30.090909 | 81 | 0.596677 |
504c2899262df11b36c35502bc994aff22b34dca | 30,739 | py | Python | fastapi/applications.py | Future-Position-X/fastapi | 4d3f781bcf7bad93b41482bb24b5b29f39778b76 | [
"MIT"
]
| null | null | null | fastapi/applications.py | Future-Position-X/fastapi | 4d3f781bcf7bad93b41482bb24b5b29f39778b76 | [
"MIT"
]
| null | null | null | fastapi/applications.py | Future-Position-X/fastapi | 4d3f781bcf7bad93b41482bb24b5b29f39778b76 | [
"MIT"
]
| null | null | null | from typing import Any, Callable, Dict, List, Optional, Sequence, Type, Union
from fastapi import routing
from fastapi.concurrency import AsyncExitStack
from fastapi.encoders import DictIntStrAny, SetIntStr
from fastapi.exception_handlers import (
http_exception_handler,
request_validation_exception_handler,
)
from fastapi.exceptions import RequestValidationError
from fastapi.logger import logger
from fastapi.openapi.docs import (
get_redoc_html,
get_swagger_ui_html,
get_swagger_ui_oauth2_redirect_html,
)
from fastapi.openapi.utils import get_openapi
from fastapi.params import Depends
from starlette.applications import Starlette
from starlette.datastructures import State
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.types import Receive, Scope, Send
class FastAPI(Starlette):
def __init__(
self,
*,
debug: bool = False,
routes: Optional[List[BaseRoute]] = None,
title: str = "FastAPI",
description: str = "",
version: str = "0.1.0",
openapi_url: Optional[str] = "/openapi.json",
openapi_tags: Optional[List[Dict[str, Any]]] = None,
servers: Optional[List[Dict[str, Union[str, Any]]]] = None,
default_response_class: Type[Response] = JSONResponse,
docs_url: Optional[str] = "/docs",
redoc_url: Optional[str] = "/redoc",
swagger_ui_oauth2_redirect_url: Optional[str] = "/docs/oauth2-redirect",
swagger_ui_init_oauth: Optional[dict] = None,
middleware: Optional[Sequence[Middleware]] = None,
exception_handlers: Optional[
Dict[Union[int, Type[Exception]], Callable]
] = None,
on_startup: Optional[Sequence[Callable]] = None,
on_shutdown: Optional[Sequence[Callable]] = None,
openapi_prefix: str = "",
root_path: str = "",
root_path_in_servers: bool = True,
**extra: Any,
) -> None:
self.default_response_class = default_response_class
self._debug = debug
self.state = State()
self.router: routing.APIRouter = routing.APIRouter(
routes,
dependency_overrides_provider=self,
on_startup=on_startup,
on_shutdown=on_shutdown,
)
self.exception_handlers = (
{} if exception_handlers is None else dict(exception_handlers)
)
self.user_middleware = [] if middleware is None else list(middleware)
self.middleware_stack = self.build_middleware_stack()
self.title = title
self.description = description
self.version = version
self.servers = servers or []
self.openapi_url = openapi_url
self.openapi_tags = openapi_tags
# TODO: remove when discarding the openapi_prefix parameter
if openapi_prefix:
logger.warning(
'"openapi_prefix" has been deprecated in favor of "root_path", which '
"follows more closely the ASGI standard, is simpler, and more "
"automatic. Check the docs at "
"https://fastapi.tiangolo.com/advanced/sub-applications/"
)
self.root_path = root_path or openapi_prefix
self.root_path_in_servers = root_path_in_servers
self.docs_url = docs_url
self.redoc_url = redoc_url
self.swagger_ui_oauth2_redirect_url = swagger_ui_oauth2_redirect_url
self.swagger_ui_init_oauth = swagger_ui_init_oauth
self.extra = extra
self.dependency_overrides: Dict[Callable, Callable] = {}
self.openapi_version = "3.0.2"
if self.openapi_url:
assert self.title, "A title must be provided for OpenAPI, e.g.: 'My API'"
assert self.version, "A version must be provided for OpenAPI, e.g.: '2.1.0'"
self.openapi_schema: Optional[Dict[str, Any]] = None
self.setup()
def openapi(self) -> Dict:
if not self.openapi_schema:
self.openapi_schema = get_openapi(
title=self.title,
version=self.version,
openapi_version=self.openapi_version,
description=self.description,
routes=self.routes,
tags=self.openapi_tags,
servers=self.servers,
)
return self.openapi_schema
def setup(self) -> None:
if self.openapi_url:
urls = (server_data.get("url") for server_data in self.servers)
server_urls = {url for url in urls if url}
async def openapi(req: Request) -> JSONResponse:
root_path = req.scope.get("root_path", "").rstrip("/")
if root_path not in server_urls:
if root_path and self.root_path_in_servers:
self.servers.insert(0, {"url": root_path})
server_urls.add(root_path)
return JSONResponse(self.openapi())
self.add_route(self.openapi_url, openapi, include_in_schema=False)
if self.openapi_url and self.docs_url:
async def swagger_ui_html(req: Request) -> HTMLResponse:
root_path = req.scope.get("root_path", "").rstrip("/")
openapi_url = root_path + self.openapi_url
oauth2_redirect_url = self.swagger_ui_oauth2_redirect_url
if oauth2_redirect_url:
oauth2_redirect_url = root_path + oauth2_redirect_url
return get_swagger_ui_html(
openapi_url=openapi_url,
title=self.title + " - Swagger UI",
oauth2_redirect_url=oauth2_redirect_url,
init_oauth=self.swagger_ui_init_oauth,
)
self.add_route(self.docs_url, swagger_ui_html, include_in_schema=False)
if self.swagger_ui_oauth2_redirect_url:
async def swagger_ui_redirect(req: Request) -> HTMLResponse:
return get_swagger_ui_oauth2_redirect_html()
self.add_route(
self.swagger_ui_oauth2_redirect_url,
swagger_ui_redirect,
include_in_schema=False,
)
if self.openapi_url and self.redoc_url:
async def redoc_html(req: Request) -> HTMLResponse:
root_path = req.scope.get("root_path", "").rstrip("/")
openapi_url = root_path + self.openapi_url
return get_redoc_html(
openapi_url=openapi_url, title=self.title + " - ReDoc"
)
self.add_route(self.redoc_url, redoc_html, include_in_schema=False)
self.add_exception_handler(HTTPException, http_exception_handler)
self.add_exception_handler(
RequestValidationError, request_validation_exception_handler
)
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
if self.root_path:
scope["root_path"] = self.root_path
if AsyncExitStack:
async with AsyncExitStack() as stack:
scope["fastapi_astack"] = stack
await super().__call__(scope, receive, send)
else:
await super().__call__(scope, receive, send) # pragma: no cover
def add_api_route(
self,
path: str,
endpoint: Callable,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
methods: Optional[List[str]] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
**extra: Any,
) -> None:
self.router.add_api_route(
path,
endpoint=endpoint,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
methods=methods,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
**extra,
)
def api_route(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
methods: Optional[List[str]] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
**extra: Any,
) -> Callable:
def decorator(func: Callable) -> Callable:
self.router.add_api_route(
path,
func,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
methods=methods,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
**extra,
)
return func
return decorator
def add_api_websocket_route(
self, path: str, endpoint: Callable, name: Optional[str] = None
) -> None:
self.router.add_api_websocket_route(path, endpoint, name=name)
def websocket(self, path: str, name: Optional[str] = None) -> Callable:
def decorator(func: Callable) -> Callable:
self.add_api_websocket_route(path, func, name=name)
return func
return decorator
def include_router(
self,
router: routing.APIRouter,
*,
prefix: str = "",
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
default_response_class: Optional[Type[Response]] = None,
) -> None:
self.router.include_router(
router,
prefix=prefix,
tags=tags,
dependencies=dependencies,
responses=responses or {},
default_response_class=default_response_class
or self.default_response_class,
)
def get(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.get(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
def put(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.put(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
def post(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.post(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
def delete(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.delete(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
operation_id=operation_id,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
def options(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.options(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
def head(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.head(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
def patch(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.patch(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
def trace(
self,
path: str,
*,
response_model: Optional[Type[Any]] = None,
status_code: int = 200,
tags: Optional[List[str]] = None,
dependencies: Optional[Sequence[Depends]] = None,
summary: Optional[str] = None,
description: Optional[str] = None,
response_description: str = "Successful Response",
responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
deprecated: Optional[bool] = None,
operation_id: Optional[str] = None,
response_model_include: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None,
response_model_by_alias: bool = True,
response_model_exclude_unset: bool = False,
response_model_exclude_defaults: bool = False,
response_model_exclude_none: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
name: Optional[str] = None,
callbacks: Optional[List[routing.APIRoute]] = None,
**extra: Any,
) -> Callable:
return self.router.trace(
path,
response_model=response_model,
status_code=status_code,
tags=tags or [],
dependencies=dependencies,
summary=summary,
description=description,
response_description=response_description,
responses=responses or {},
deprecated=deprecated,
operation_id=operation_id,
response_model_include=response_model_include,
response_model_exclude=response_model_exclude,
response_model_by_alias=response_model_by_alias,
response_model_exclude_unset=response_model_exclude_unset,
response_model_exclude_defaults=response_model_exclude_defaults,
response_model_exclude_none=response_model_exclude_none,
include_in_schema=include_in_schema,
response_class=response_class or self.default_response_class,
name=name,
callbacks=callbacks,
**extra,
)
| 42.050616 | 88 | 0.632324 |
8e2a4f61243636e0bedfbd8d8fa519c9b6aa992b | 3,168 | py | Python | src/LightCNN/evaluation/feature_extraction/layer.py | willyspinner/High-Performance-Face-Recognition | c5caad61be97fd20f9c47a727278ff938dc5cc8f | [
"MIT"
]
| 300 | 2019-01-28T07:37:53.000Z | 2022-03-09T02:17:28.000Z | src/LightCNN/evaluation/feature_extraction/layer.py | willyspinner/High-Performance-Face-Recognition | c5caad61be97fd20f9c47a727278ff938dc5cc8f | [
"MIT"
]
| 15 | 2019-04-22T14:23:01.000Z | 2021-11-24T09:52:32.000Z | src/LightCNN/evaluation/feature_extraction/layer.py | willyspinner/High-Performance-Face-Recognition | c5caad61be97fd20f9c47a727278ff938dc5cc8f | [
"MIT"
]
| 67 | 2019-01-29T05:42:09.000Z | 2021-12-28T11:09:44.000Z | import tensorflow as tf
import numpy as np
def weight(shape):
return tf.get_variable('weight', shape, initializer=tf.contrib.layers.xavier_initializer())
def bias(shape, value=0.1):
return tf.get_variable('bias', shape, initializer=tf.constant_initializer(value))
def Fcnn(x,insize,outsize,name,activation=None,nobias=False):
with tf.variable_scope(name):
if nobias:
print('No biased fully connected layer is used!')
W = weight([insize,outsize])
tf.summary.histogram(name+'/weight',W)
if activation==None:
return tf.matmul(x,W)
return activation(tf.matmul(x,W))
else:
W = weight([insize,outsize])
b = bias([outsize])
tf.summary.histogram(name+'/weight',W)
tf.summary.histogram(name+'/bias',b)
if activation==None:
return tf.matmul(x,W)+b
return activation(tf.matmul(x,W)+b)
def conv2D(x,kernel_size,outchn,name,stride=1,pad='SAME', usebias=True):
print('Conv_bias:',usebias)
# with tf.variable_scope(name):
# if isinstance(size,list):
# kernel = size
# else:
kernel = [kernel_size, kernel_size]
z = tf.layers.conv2d(x, outchn, kernel, strides=(stride, stride), padding=pad,\
kernel_initializer=tf.contrib.layers.xavier_initializer_conv2d(),\
use_bias=usebias,\
bias_initializer=tf.constant_initializer(0.1),name=name)
# print ('z:', z.get_shape())
return z
def maxpooling(x,size,stride,name,pad='SAME'):
with tf.variable_scope(name):
return tf.nn.max_pool(x,ksize=[1,size,size,1],strides=[1,stride,stride,1],padding=pad)
def avgpooling(x,size,stride,name,pad='SAME'):
with tf.variable_scope(name):
return tf.nn.avg_pool(x,ksize=[1,size,size,1],strides=[1,stride,stride,1],padding=pad)
def MFM(x,name):
with tf.variable_scope(name):
shape = x.get_shape().as_list()
res = tf.reshape(x,[-1,shape[1],shape[2],2,shape[-1]//2])
res = tf.reduce_max(res,axis=[3])
return res
def MFMfc(x,half,name):
with tf.variable_scope(name):
shape = x.get_shape().as_list()
# print('fcshape:',shape)
res = tf.reduce_max(tf.reshape(x,[-1,2,shape[-1]//2]),reduction_indices=[1])
return res
def batch_norm(inp,name,training=True):
print('BN training:',training)
return tf.layers.batch_normalization(inp,training=training,name=name)
def L2_norm(inp, dim):
print ('L2 normlization...')
return tf.nn.l2_norm(inp, dim)
def lrelu(x,name,leaky=0.2):
return tf.maximum(x,x*leaky,name=name)
def relu(inp,name):
return tf.nn.relu(inp,name=name)
def tanh(inp,name):
return tf.tanh(inp,name=name)
def elu(inp,name):
return tf.nn.elu(inp,name=name)
def sparse_softmax_cross_entropy(inp,lab,name):
with tf.name_scope(name):
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=lab,logits=inp))
return loss
def sigmoid(inp,name):
return tf.sigmoid(inp,name=name)
def resize_nn(inp,size,name):
with tf.name_scope(name):
return tf.image.resize_nearest_neighbor(inp,size=(int(size),int(size)))
def accuracy(pred,y,name):
with tf.variable_scope(name):
correct = tf.equal(tf.cast(tf.argmax(pred,1),tf.int64),tf.cast(y,tf.int64))
acc = tf.reduce_mean(tf.cast(correct,tf.float32))
return acc
def dropout(inp, keep_prob):
return tf.nn.dropout(inp,keep_prob)
| 29.886792 | 94 | 0.722854 |
23fb5eed02e074131c3e4705d23fbafabdca78c7 | 426 | py | Python | Python/Strings/Capitalize/solution.py | aesavas/HackerRank | c1ffecc92e3e3db923f94594b9115f650dc2983a | [
"MIT"
]
| null | null | null | Python/Strings/Capitalize/solution.py | aesavas/HackerRank | c1ffecc92e3e3db923f94594b9115f650dc2983a | [
"MIT"
]
| null | null | null | Python/Strings/Capitalize/solution.py | aesavas/HackerRank | c1ffecc92e3e3db923f94594b9115f650dc2983a | [
"MIT"
]
| null | null | null | """
author : Ali Emre SAVAS
Link : https://www.hackerrank.com/challenges/capitalize/problem
"""
# If you want to use in Hackerrank, just copy the function. Main section is different in Hackerrank.
def solve(s):
name = s.split(" ")
for i in range(len(name)):
name[i] = name[i].capitalize()
return " ".join(name)
if __name__ == '__main__':
s = input()
result = solve(s)
print(result)
| 22.421053 | 100 | 0.626761 |
ee9c15ada17990d87fc7d4136efd5734dea4b021 | 1,794 | py | Python | backend/pyrogram/types/messages_and_media/message_reply_header.py | appheap/social-media-analyzer | 0f9da098bfb0b4f9eb38e0244aa3a168cf97d51c | [
"Apache-2.0"
]
| 5 | 2021-09-11T22:01:15.000Z | 2022-03-16T21:33:42.000Z | backend/pyrogram/types/messages_and_media/message_reply_header.py | iamatlasss/social-media-analyzer | 429d1d2bbd8bfce80c50c5f8edda58f87ace668d | [
"Apache-2.0"
]
| null | null | null | backend/pyrogram/types/messages_and_media/message_reply_header.py | iamatlasss/social-media-analyzer | 429d1d2bbd8bfce80c50c5f8edda58f87ace668d | [
"Apache-2.0"
]
| 3 | 2022-01-18T11:06:22.000Z | 2022-02-26T13:39:28.000Z | import pyrogram
from pyrogram import types, raw
from ..object import Object
class MessageReplyHeader(Object):
"""
"""
def __init__(
self,
*,
client: "pyrogram.Client" = None,
reply_to_message_id: int = None,
reply_to_user: "types.User" = None,
reply_to_chat: "types.Chat" = None,
reply_to_top_id: int = None,
):
super().__init__(client=client)
self.reply_to_message_id = reply_to_message_id
self.reply_to_user = reply_to_user
self.reply_to_chat = reply_to_chat
self.reply_to_top_id = reply_to_top_id
@staticmethod
def _parse(client, message_reply_header: raw.base.MessageReplyHeader, users: dict, chats: dict):
if message_reply_header is None:
return None
reply_to_peer_id = getattr(message_reply_header, 'reply_to_peer_id', None)
reply_to_user = None
reply_to_chat = None
if reply_to_peer_id:
if isinstance(reply_to_peer_id, raw.types.PeerUser):
reply_to_user = types.User._parse(client, users.get(reply_to_peer_id.user_id, None))
else:
if isinstance(reply_to_peer_id, raw.types.PeerChannel):
_peer_id = reply_to_peer_id.channel_id
else:
_peer_id = reply_to_peer_id.chat_id
reply_to_chat = types.Chat._parse_chat(client, chats.get(_peer_id, None))
return MessageReplyHeader(
client=client,
reply_to_message_id=message_reply_header.reply_to_msg_id,
reply_to_user=reply_to_user,
reply_to_chat=reply_to_chat,
reply_to_top_id=getattr(message_reply_header, 'reply_to_top_id', None),
)
| 33.849057 | 100 | 0.62932 |
941ba32cd0bf9012dec28acabf8badddce0b4e84 | 107,640 | py | Python | sympy/printing/pretty/tests/test_pretty.py | ovolve/sympy | 0a15782f20505673466b940454b33b8014a25c13 | [
"BSD-3-Clause"
]
| 1 | 2016-02-22T22:46:50.000Z | 2016-02-22T22:46:50.000Z | sympy/printing/pretty/tests/test_pretty.py | ovolve/sympy | 0a15782f20505673466b940454b33b8014a25c13 | [
"BSD-3-Clause"
]
| 7 | 2017-05-01T14:15:32.000Z | 2017-09-06T20:44:24.000Z | sympy/printing/pretty/tests/test_pretty.py | ovolve/sympy | 0a15782f20505673466b940454b33b8014a25c13 | [
"BSD-3-Clause"
]
| 1 | 2016-04-06T15:05:37.000Z | 2016-04-06T15:05:37.000Z | # -*- coding: utf-8 -*-
from sympy import (
Add, And, Basic, Derivative, Dict, Eq, Equivalent, FF,
FiniteSet, Function, Ge, Gt, I, Implies, Integral,
Lambda, Le, Limit, Lt, Matrix, Mul, Nand, Ne, Nor, Not, O, Or,
Pow, Product, QQ, RR, Rational, Ray, rootof, RootSum, S,
Segment, Subs, Sum, Symbol, Tuple, Trace, Xor, ZZ, conjugate,
groebner, oo, pi, symbols, ilex, grlex, Range, Contains,
SeqPer, SeqFormula, SeqAdd, SeqMul, Interval, Union, fourier_series, fps,
Complement, FiniteSet, Interval, Intersection, Union)
from sympy.functions import (Abs, Chi, Ci, Ei, KroneckerDelta,
Piecewise, Shi, Si, atan2, binomial, catalan, ceiling, cos,
euler, exp, expint, factorial, factorial2, floor, gamma, hyper, log,
lowergamma, meijerg, sin, sqrt, subfactorial, tan, uppergamma,
elliptic_k, elliptic_f, elliptic_e, elliptic_pi)
from sympy.matrices import Adjoint, Inverse, MatrixSymbol, Transpose
from sympy.printing.codeprinter import Assignment
from sympy.printing.pretty import pretty as xpretty
from sympy.printing.pretty import pprint
from sympy.physics.units import joule
from sympy.utilities.pytest import raises, XFAIL
from sympy.core.trace import Tr
from sympy.core.compatibility import u_decode as u
from sympy.core.compatibility import range
a, b, x, y, z, k = symbols('a,b,x,y,z,k')
th = Symbol('theta')
ph = Symbol('phi')
"""
Expressions whose pretty-printing is tested here:
(A '#' to the right of an expression indicates that its various acceptable
orderings are accounted for by the tests.)
BASIC EXPRESSIONS:
oo
(x**2)
1/x
y*x**-2
x**Rational(-5,2)
(-2)**x
Pow(3, 1, evaluate=False)
(x**2 + x + 1) #
1-x #
1-2*x #
x/y
-x/y
(x+2)/y #
(1+x)*y #3
-5*x/(x+10) # correct placement of negative sign
1 - Rational(3,2)*(x+1)
-(-x + 5)*(-x - 2*sqrt(2) + 5) - (-y + 5)*(-y + 5) # issue 5524
ORDERING:
x**2 + x + 1
1 - x
1 - 2*x
2*x**4 + y**2 - x**2 + y**3
RELATIONAL:
Eq(x, y)
Lt(x, y)
Gt(x, y)
Le(x, y)
Ge(x, y)
Ne(x/(y+1), y**2) #
RATIONAL NUMBERS:
y*x**-2
y**Rational(3,2) * x**Rational(-5,2)
sin(x)**3/tan(x)**2
FUNCTIONS (ABS, CONJ, EXP, FUNCTION BRACES, FACTORIAL, FLOOR, CEILING):
(2*x + exp(x)) #
Abs(x)
Abs(x/(x**2+1)) #
Abs(1 / (y - Abs(x)))
factorial(n)
factorial(2*n)
subfactorial(n)
subfactorial(2*n)
factorial(factorial(factorial(n)))
factorial(n+1) #
conjugate(x)
conjugate(f(x+1)) #
f(x)
f(x, y)
f(x/(y+1), y) #
f(x**x**x**x**x**x)
sin(x)**2
conjugate(a+b*I)
conjugate(exp(a+b*I))
conjugate( f(1 + conjugate(f(x))) ) #
f(x/(y+1), y) # denom of first arg
floor(1 / (y - floor(x)))
ceiling(1 / (y - ceiling(x)))
SQRT:
sqrt(2)
2**Rational(1,3)
2**Rational(1,1000)
sqrt(x**2 + 1)
(1 + sqrt(5))**Rational(1,3)
2**(1/x)
sqrt(2+pi)
(2+(1+x**2)/(2+x))**Rational(1,4)+(1+x**Rational(1,1000))/sqrt(3+x**2)
DERIVATIVES:
Derivative(log(x), x, evaluate=False)
Derivative(log(x), x, evaluate=False) + x #
Derivative(log(x) + x**2, x, y, evaluate=False)
Derivative(2*x*y, y, x, evaluate=False) + x**2 #
beta(alpha).diff(alpha)
INTEGRALS:
Integral(log(x), x)
Integral(x**2, x)
Integral((sin(x))**2 / (tan(x))**2)
Integral(x**(2**x), x)
Integral(x**2, (x,1,2))
Integral(x**2, (x,Rational(1,2),10))
Integral(x**2*y**2, x,y)
Integral(x**2, (x, None, 1))
Integral(x**2, (x, 1, None))
Integral(sin(th)/cos(ph), (th,0,pi), (ph, 0, 2*pi))
MATRICES:
Matrix([[x**2+1, 1], [y, x+y]]) #
Matrix([[x/y, y, th], [0, exp(I*k*ph), 1]])
PIECEWISE:
Piecewise((x,x<1),(x**2,True))
SEQUENCES (TUPLES, LISTS, DICTIONARIES):
()
[]
{}
(1/x,)
[x**2, 1/x, x, y, sin(th)**2/cos(ph)**2]
(x**2, 1/x, x, y, sin(th)**2/cos(ph)**2)
{x: sin(x)}
{1/x: 1/y, x: sin(x)**2} #
[x**2]
(x**2,)
{x**2: 1}
LIMITS:
Limit(x, x, oo)
Limit(x**2, x, 0)
Limit(1/x, x, 0)
Limit(sin(x)/x, x, 0)
UNITS:
joule => kg*m**2/s
SUBS:
Subs(f(x), x, ph**2)
Subs(f(x).diff(x), x, 0)
Subs(f(x).diff(x)/y, (x, y), (0, Rational(1, 2)))
ORDER:
O(1)
O(1/x)
O(x**2 + y**2)
"""
def pretty(expr, order=None):
"""ASCII pretty-printing"""
return xpretty(expr, order=order, use_unicode=False, wrap_line=False)
def upretty(expr, order=None):
"""Unicode pretty-printing"""
return xpretty(expr, order=order, use_unicode=True, wrap_line=False)
def test_pretty_ascii_str():
assert pretty( 'xxx' ) == 'xxx'
assert pretty( "xxx" ) == 'xxx'
assert pretty( 'xxx\'xxx' ) == 'xxx\'xxx'
assert pretty( 'xxx"xxx' ) == 'xxx\"xxx'
assert pretty( 'xxx\"xxx' ) == 'xxx\"xxx'
assert pretty( "xxx'xxx" ) == 'xxx\'xxx'
assert pretty( "xxx\'xxx" ) == 'xxx\'xxx'
assert pretty( "xxx\"xxx" ) == 'xxx\"xxx'
assert pretty( "xxx\"xxx\'xxx" ) == 'xxx"xxx\'xxx'
assert pretty( "xxx\nxxx" ) == 'xxx\nxxx'
def test_pretty_unicode_str():
assert pretty( u('xxx') ) == u('xxx')
assert pretty( u('xxx') ) == u('xxx')
assert pretty( u('xxx\'xxx') ) == u('xxx\'xxx')
assert pretty( u('xxx"xxx') ) == u('xxx\"xxx')
assert pretty( u('xxx\"xxx') ) == u('xxx\"xxx')
assert pretty( u("xxx'xxx") ) == u('xxx\'xxx')
assert pretty( u("xxx\'xxx") ) == u('xxx\'xxx')
assert pretty( u("xxx\"xxx") ) == u('xxx\"xxx')
assert pretty( u("xxx\"xxx\'xxx") ) == u('xxx"xxx\'xxx')
assert pretty( u("xxx\nxxx") ) == u('xxx\nxxx')
def test_upretty_greek():
assert upretty( oo ) == u('∞')
assert upretty( Symbol('alpha^+_1') ) == u('α⁺₁')
assert upretty( Symbol('beta') ) == u('β')
assert upretty(Symbol('lambda')) == u('λ')
def test_upretty_multiindex():
assert upretty( Symbol('beta12') ) == u('β₁₂')
assert upretty( Symbol('Y00') ) == u('Y₀₀')
assert upretty( Symbol('Y_00') ) == u('Y₀₀')
assert upretty( Symbol('F^+-') ) == u('F⁺⁻')
def test_upretty_sub_super():
assert upretty( Symbol('beta_1_2') ) == u('β₁ ₂')
assert upretty( Symbol('beta^1^2') ) == u('β¹ ²')
assert upretty( Symbol('beta_1^2') ) == u('β²₁')
assert upretty( Symbol('beta_10_20') ) == u('β₁₀ ₂₀')
assert upretty( Symbol('beta_ax_gamma^i') ) == u('βⁱₐₓ ᵧ')
assert upretty( Symbol("F^1^2_3_4") ) == u('F¹ ²₃ ₄')
assert upretty( Symbol("F_1_2^3^4") ) == u('F³ ⁴₁ ₂')
assert upretty( Symbol("F_1_2_3_4") ) == u('F₁ ₂ ₃ ₄')
assert upretty( Symbol("F^1^2^3^4") ) == u('F¹ ² ³ ⁴')
def test_upretty_subs_missing_in_24():
assert upretty( Symbol('F_beta') ) == u('Fᵦ')
assert upretty( Symbol('F_gamma') ) == u('Fᵧ')
assert upretty( Symbol('F_rho') ) == u('Fᵨ')
assert upretty( Symbol('F_phi') ) == u('Fᵩ')
assert upretty( Symbol('F_chi') ) == u('Fᵪ')
assert upretty( Symbol('F_a') ) == u('Fₐ')
assert upretty( Symbol('F_e') ) == u('Fₑ')
assert upretty( Symbol('F_i') ) == u('Fᵢ')
assert upretty( Symbol('F_o') ) == u('Fₒ')
assert upretty( Symbol('F_u') ) == u('Fᵤ')
assert upretty( Symbol('F_r') ) == u('Fᵣ')
assert upretty( Symbol('F_v') ) == u('Fᵥ')
assert upretty( Symbol('F_x') ) == u('Fₓ')
@XFAIL
def test_missing_in_2X_issue_9047():
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
assert upretty( Symbol('F_h') ) == u('Fₕ')
assert upretty( Symbol('F_k') ) == u('Fₖ')
assert upretty( Symbol('F_l') ) == u('Fₗ')
assert upretty( Symbol('F_m') ) == u('Fₘ')
assert upretty( Symbol('F_n') ) == u('Fₙ')
assert upretty( Symbol('F_p') ) == u('Fₚ')
assert upretty( Symbol('F_s') ) == u('Fₛ')
assert upretty( Symbol('F_t') ) == u('Fₜ')
def test_upretty_modifiers():
# Accents
assert upretty( Symbol('Fmathring') ) == u('F̊')
assert upretty( Symbol('Fddddot') ) == u('F̈̈')
assert upretty( Symbol('Fdddot') ) == u('F̈̇')
assert upretty( Symbol('Fddot') ) == u('F̈')
assert upretty( Symbol('Fdot') ) == u('Ḟ')
assert upretty( Symbol('Fcheck') ) == u('F̌')
assert upretty( Symbol('Fbreve') ) == u('F̆')
assert upretty( Symbol('Facute') ) == u('F́')
assert upretty( Symbol('Fgrave') ) == u('F̀')
assert upretty( Symbol('Ftilde') ) == u('F̃')
assert upretty( Symbol('Fhat') ) == u('F̂')
assert upretty( Symbol('Fbar') ) == u('F̅')
assert upretty( Symbol('Fvec') ) == u('F⃗')
assert upretty( Symbol('Fprime') ) == u('F′')
assert upretty( Symbol('Fprm') ) == u('F′')
# No faces are actually implemented, but test to make sure the modifiers are stripped
assert upretty( Symbol('Fbold') ) == u('Fbold')
assert upretty( Symbol('Fbm') ) == u('Fbm')
assert upretty( Symbol('Fcal') ) == u('Fcal')
assert upretty( Symbol('Fscr') ) == u('Fscr')
assert upretty( Symbol('Ffrak') ) == u('Ffrak')
# Brackets
assert upretty( Symbol('Fnorm') ) == u('‖F‖')
assert upretty( Symbol('Favg') ) == u('⟨F⟩')
assert upretty( Symbol('Fabs') ) == u('|F|')
assert upretty( Symbol('Fmag') ) == u('|F|')
# Combinations
assert upretty( Symbol('xvecdot') ) == u('x⃗̇')
assert upretty( Symbol('xDotVec') ) == u('ẋ⃗')
assert upretty( Symbol('xHATNorm') ) == u('‖x̂‖')
assert upretty( Symbol('xMathring_yCheckPRM__zbreveAbs') ) == u('x̊_y̌′__|z̆|')
assert upretty( Symbol('alphadothat_nVECDOT__tTildePrime') ) == u('α̇̂_n⃗̇__t̃′')
assert upretty( Symbol('x_dot') ) == u('x_dot')
assert upretty( Symbol('x__dot') ) == u('x__dot')
def test_pretty_Cycle():
from sympy.combinatorics.permutations import Cycle
assert pretty(Cycle(1, 2)) == '(1 2)'
assert pretty(Cycle(2)) == '(2)'
assert pretty(Cycle(1, 3)(4, 5)) == '(1 3)(4 5)'
assert pretty(Cycle()) == '()'
def test_pretty_basic():
assert pretty( -Rational(1)/2 ) == '-1/2'
assert pretty( -Rational(13)/22 ) == \
"""\
-13 \n\
----\n\
22 \
"""
expr = oo
ascii_str = \
"""\
oo\
"""
ucode_str = \
u("""\
∞\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x**2)
ascii_str = \
"""\
2\n\
x \
"""
ucode_str = \
u("""\
2\n\
x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = 1/x
ascii_str = \
"""\
1\n\
-\n\
x\
"""
ucode_str = \
u("""\
1\n\
─\n\
x\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
# not the same as 1/x
expr = x**-1.0
ascii_str = \
"""\
-1.0\n\
x \
"""
ucode_str = \
("""\
-1.0\n\
x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
# see issue #2860
expr = Pow(S(2), -1.0, evaluate=False)
ascii_str = \
"""\
-1.0\n\
2 \
"""
ucode_str = \
("""\
-1.0\n\
2 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = y*x**-2
ascii_str = \
"""\
y \n\
--\n\
2\n\
x \
"""
ucode_str = \
u("""\
y \n\
──\n\
2\n\
x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = x**Rational(-5, 2)
ascii_str = \
"""\
1 \n\
----\n\
5/2\n\
x \
"""
ucode_str = \
u("""\
1 \n\
────\n\
5/2\n\
x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (-2)**x
ascii_str = \
"""\
x\n\
(-2) \
"""
ucode_str = \
u("""\
x\n\
(-2) \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
# See issue 4923
expr = Pow(3, 1, evaluate=False)
ascii_str = \
"""\
1\n\
3 \
"""
ucode_str = \
u("""\
1\n\
3 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x**2 + x + 1)
ascii_str_1 = \
"""\
2\n\
1 + x + x \
"""
ascii_str_2 = \
"""\
2 \n\
x + x + 1\
"""
ascii_str_3 = \
"""\
2 \n\
x + 1 + x\
"""
ucode_str_1 = \
u("""\
2\n\
1 + x + x \
""")
ucode_str_2 = \
u("""\
2 \n\
x + x + 1\
""")
ucode_str_3 = \
u("""\
2 \n\
x + 1 + x\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
expr = 1 - x
ascii_str_1 = \
"""\
1 - x\
"""
ascii_str_2 = \
"""\
-x + 1\
"""
ucode_str_1 = \
u("""\
1 - x\
""")
ucode_str_2 = \
u("""\
-x + 1\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = 1 - 2*x
ascii_str_1 = \
"""\
1 - 2*x\
"""
ascii_str_2 = \
"""\
-2*x + 1\
"""
ucode_str_1 = \
u("""\
1 - 2⋅x\
""")
ucode_str_2 = \
u("""\
-2⋅x + 1\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = x/y
ascii_str = \
"""\
x\n\
-\n\
y\
"""
ucode_str = \
u("""\
x\n\
─\n\
y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -x/y
ascii_str = \
"""\
-x \n\
---\n\
y \
"""
ucode_str = \
u("""\
-x \n\
───\n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x + 2)/y
ascii_str_1 = \
"""\
2 + x\n\
-----\n\
y \
"""
ascii_str_2 = \
"""\
x + 2\n\
-----\n\
y \
"""
ucode_str_1 = \
u("""\
2 + x\n\
─────\n\
y \
""")
ucode_str_2 = \
u("""\
x + 2\n\
─────\n\
y \
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = (1 + x)*y
ascii_str_1 = \
"""\
y*(1 + x)\
"""
ascii_str_2 = \
"""\
(1 + x)*y\
"""
ascii_str_3 = \
"""\
y*(x + 1)\
"""
ucode_str_1 = \
u("""\
y⋅(1 + x)\
""")
ucode_str_2 = \
u("""\
(1 + x)⋅y\
""")
ucode_str_3 = \
u("""\
y⋅(x + 1)\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
# Test for correct placement of the negative sign
expr = -5*x/(x + 10)
ascii_str_1 = \
"""\
-5*x \n\
------\n\
10 + x\
"""
ascii_str_2 = \
"""\
-5*x \n\
------\n\
x + 10\
"""
ucode_str_1 = \
u("""\
-5⋅x \n\
──────\n\
10 + x\
""")
ucode_str_2 = \
u("""\
-5⋅x \n\
──────\n\
x + 10\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = -S(1)/2 - 3*x
ascii_str = \
"""\
-3*x - 1/2\
"""
ucode_str = \
u("""\
-3⋅x - 1/2\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = S(1)/2 - 3*x
ascii_str = \
"""\
-3*x + 1/2\
"""
ucode_str = \
u("""\
-3⋅x + 1/2\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -S(1)/2 - 3*x/2
ascii_str = \
"""\
3*x 1\n\
- --- - -\n\
2 2\
"""
ucode_str = \
u("""\
3⋅x 1\n\
- ─── - ─\n\
2 2\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = S(1)/2 - 3*x/2
ascii_str = \
"""\
3*x 1\n\
- --- + -\n\
2 2\
"""
ucode_str = \
u("""\
3⋅x 1\n\
- ─── + ─\n\
2 2\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_negative_fractions():
expr = -x/y
ascii_str =\
"""\
-x \n\
---\n\
y \
"""
ucode_str =\
u("""\
-x \n\
───\n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -x*z/y
ascii_str =\
"""\
-x*z \n\
-----\n\
y \
"""
ucode_str =\
u("""\
-x⋅z \n\
─────\n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = x**2/y
ascii_str =\
"""\
2\n\
x \n\
--\n\
y \
"""
ucode_str =\
u("""\
2\n\
x \n\
──\n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -x**2/y
ascii_str =\
"""\
2 \n\
-x \n\
----\n\
y \
"""
ucode_str =\
u("""\
2 \n\
-x \n\
────\n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -x/(y*z)
ascii_str =\
"""\
-x \n\
---\n\
y*z\
"""
ucode_str =\
u("""\
-x \n\
───\n\
y⋅z\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -a/y**2
ascii_str =\
"""\
-a \n\
---\n\
2\n\
y \
"""
ucode_str =\
u("""\
-a \n\
───\n\
2\n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = y**(-a/b)
ascii_str =\
"""\
-a \n\
---\n\
b \n\
y \
"""
ucode_str =\
u("""\
-a \n\
───\n\
b \n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -1/y**2
ascii_str =\
"""\
-1 \n\
---\n\
2\n\
y \
"""
ucode_str =\
u("""\
-1 \n\
───\n\
2\n\
y \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -10/b**2
ascii_str =\
"""\
-10 \n\
----\n\
2 \n\
b \
"""
ucode_str =\
u("""\
-10 \n\
────\n\
2 \n\
b \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Rational(-200, 37)
ascii_str =\
"""\
-200 \n\
-----\n\
37 \
"""
ucode_str =\
u("""\
-200 \n\
─────\n\
37 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_issue_5524():
assert pretty(-(-x + 5)*(-x - 2*sqrt(2) + 5) - (-y + 5)*(-y + 5)) == \
"""\
/ ___ \\ 2\n\
(x - 5)*\\-x - 2*\\/ 2 + 5/ - (-y + 5) \
"""
assert upretty(-(-x + 5)*(-x - 2*sqrt(2) + 5) - (-y + 5)*(-y + 5)) == \
u("""\
2\n\
(x - 5)⋅(-x - 2⋅√2 + 5) - (-y + 5) \
""")
def test_pretty_ordering():
assert pretty(x**2 + x + 1, order='lex') == \
"""\
2 \n\
x + x + 1\
"""
assert pretty(x**2 + x + 1, order='rev-lex') == \
"""\
2\n\
1 + x + x \
"""
assert pretty(1 - x, order='lex') == '-x + 1'
assert pretty(1 - x, order='rev-lex') == '1 - x'
assert pretty(1 - 2*x, order='lex') == '-2*x + 1'
assert pretty(1 - 2*x, order='rev-lex') == '1 - 2*x'
f = 2*x**4 + y**2 - x**2 + y**3
assert pretty(f, order=None) == \
"""\
4 2 3 2\n\
2*x - x + y + y \
"""
assert pretty(f, order='lex') == \
"""\
4 2 3 2\n\
2*x - x + y + y \
"""
assert pretty(f, order='rev-lex') == \
"""\
2 3 2 4\n\
y + y - x + 2*x \
"""
expr = x - x**3/6 + x**5/120 + O(x**6)
ascii_str = \
"""\
3 5 \n\
x x / 6\\\n\
x - -- + --- + O\\x /\n\
6 120 \
"""
ucode_str = \
u("""\
3 5 \n\
x x ⎛ 6⎞\n\
x - ── + ─── + O⎝x ⎠\n\
6 120 \
""")
assert pretty(expr, order=None) == ascii_str
assert upretty(expr, order=None) == ucode_str
assert pretty(expr, order='lex') == ascii_str
assert upretty(expr, order='lex') == ucode_str
assert pretty(expr, order='rev-lex') == ascii_str
assert upretty(expr, order='rev-lex') == ucode_str
def test_pretty_relational():
expr = Eq(x, y)
ascii_str = \
"""\
x = y\
"""
ucode_str = \
u("""\
x = y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Lt(x, y)
ascii_str = \
"""\
x < y\
"""
ucode_str = \
u("""\
x < y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Gt(x, y)
ascii_str = \
"""\
x > y\
"""
ucode_str = \
u("""\
x > y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Le(x, y)
ascii_str = \
"""\
x <= y\
"""
ucode_str = \
u("""\
x ≤ y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Ge(x, y)
ascii_str = \
"""\
x >= y\
"""
ucode_str = \
u("""\
x ≥ y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Ne(x/(y + 1), y**2)
ascii_str_1 = \
"""\
x 2\n\
----- != y \n\
1 + y \
"""
ascii_str_2 = \
"""\
x 2\n\
----- != y \n\
y + 1 \
"""
ucode_str_1 = \
u("""\
x 2\n\
───── ≠ y \n\
1 + y \
""")
ucode_str_2 = \
u("""\
x 2\n\
───── ≠ y \n\
y + 1 \
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
def test_Assignment():
expr = Assignment(x, y)
ascii_str = \
"""\
x := y\
"""
ucode_str = \
u("""\
x := y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_issue_7117():
# See also issue #5031 (hence the evaluate=False in these).
e = Eq(x + 1, x/2)
q = Mul(2, e, evaluate=False)
assert upretty(q) == u("""\
⎛ x⎞\n\
2⋅⎜x + 1 = ─⎟\n\
⎝ 2⎠\
""")
q = Add(e, 6, evaluate=False)
assert upretty(q) == u("""\
⎛ x⎞\n\
6 + ⎜x + 1 = ─⎟\n\
⎝ 2⎠\
""")
q = Pow(e, 2, evaluate=False)
assert upretty(q) == u("""\
2\n\
⎛ x⎞ \n\
⎜x + 1 = ─⎟ \n\
⎝ 2⎠ \
""")
e2 = Eq(x, 2)
q = Mul(e, e2, evaluate=False)
assert upretty(q) == u("""\
⎛ x⎞ \n\
⎜x + 1 = ─⎟⋅(x = 2)\n\
⎝ 2⎠ \
""")
def test_pretty_rational():
expr = y*x**-2
ascii_str = \
"""\
y \n\
--\n\
2\n\
x \
"""
ucode_str = \
u("""\
y \n\
──\n\
2\n\
x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = y**Rational(3, 2) * x**Rational(-5, 2)
ascii_str = \
"""\
3/2\n\
y \n\
----\n\
5/2\n\
x \
"""
ucode_str = \
u("""\
3/2\n\
y \n\
────\n\
5/2\n\
x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = sin(x)**3/tan(x)**2
ascii_str = \
"""\
3 \n\
sin (x)\n\
-------\n\
2 \n\
tan (x)\
"""
ucode_str = \
u("""\
3 \n\
sin (x)\n\
───────\n\
2 \n\
tan (x)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_functions():
"""Tests for Abs, conjugate, exp, function braces, and factorial."""
expr = (2*x + exp(x))
ascii_str_1 = \
"""\
x\n\
2*x + e \
"""
ascii_str_2 = \
"""\
x \n\
e + 2*x\
"""
ucode_str_1 = \
u("""\
x\n\
2⋅x + ℯ \
""")
ucode_str_2 = \
u("""\
x \n\
ℯ + 2⋅x\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = Abs(x)
ascii_str = \
"""\
|x|\
"""
ucode_str = \
u("""\
│x│\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Abs(x/(x**2 + 1))
ascii_str_1 = \
"""\
| x |\n\
|------|\n\
| 2|\n\
|1 + x |\
"""
ascii_str_2 = \
"""\
| x |\n\
|------|\n\
| 2 |\n\
|x + 1|\
"""
ucode_str_1 = \
u("""\
│ x │\n\
│──────│\n\
│ 2│\n\
│1 + x │\
""")
ucode_str_2 = \
u("""\
│ x │\n\
│──────│\n\
│ 2 │\n\
│x + 1│\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = Abs(1 / (y - Abs(x)))
ascii_str = \
"""\
| 1 |\n\
|-------|\n\
|y - |x||\
"""
ucode_str = \
u("""\
│ 1 │\n\
│───────│\n\
│y - │x││\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
n = Symbol('n', integer=True)
expr = factorial(n)
ascii_str = \
"""\
n!\
"""
ucode_str = \
u("""\
n!\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = factorial(2*n)
ascii_str = \
"""\
(2*n)!\
"""
ucode_str = \
u("""\
(2⋅n)!\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = factorial(factorial(factorial(n)))
ascii_str = \
"""\
((n!)!)!\
"""
ucode_str = \
u("""\
((n!)!)!\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = factorial(n + 1)
ascii_str_1 = \
"""\
(1 + n)!\
"""
ascii_str_2 = \
"""\
(n + 1)!\
"""
ucode_str_1 = \
u("""\
(1 + n)!\
""")
ucode_str_2 = \
u("""\
(n + 1)!\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = subfactorial(n)
ascii_str = \
"""\
!n\
"""
ucode_str = \
u("""\
!n\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = subfactorial(2*n)
ascii_str = \
"""\
!(2*n)\
"""
ucode_str = \
u("""\
!(2⋅n)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
n = Symbol('n', integer=True)
expr = factorial2(n)
ascii_str = \
"""\
n!!\
"""
ucode_str = \
u("""\
n!!\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = factorial2(2*n)
ascii_str = \
"""\
(2*n)!!\
"""
ucode_str = \
u("""\
(2⋅n)!!\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = factorial2(factorial2(factorial2(n)))
ascii_str = \
"""\
((n!!)!!)!!\
"""
ucode_str = \
u("""\
((n!!)!!)!!\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = factorial2(n + 1)
ascii_str_1 = \
"""\
(1 + n)!!\
"""
ascii_str_2 = \
"""\
(n + 1)!!\
"""
ucode_str_1 = \
u("""\
(1 + n)!!\
""")
ucode_str_2 = \
u("""\
(n + 1)!!\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = 2*binomial(n, k)
ascii_str = \
"""\
/n\\\n\
2*| |\n\
\k/\
"""
ucode_str = \
u("""\
⎛n⎞\n\
2⋅⎜ ⎟\n\
⎝k⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = 2*binomial(2*n, k)
ascii_str = \
"""\
/2*n\\\n\
2*| |\n\
\ k /\
"""
ucode_str = \
u("""\
⎛2⋅n⎞\n\
2⋅⎜ ⎟\n\
⎝ k ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = 2*binomial(n**2, k)
ascii_str = \
"""\
/ 2\\\n\
|n |\n\
2*| |\n\
\k /\
"""
ucode_str = \
u("""\
⎛ 2⎞\n\
⎜n ⎟\n\
2⋅⎜ ⎟\n\
⎝k ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = catalan(n)
ascii_str = \
"""\
C \n\
n\
"""
ucode_str = \
u("""\
C \n\
n\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = conjugate(x)
ascii_str = \
"""\
_\n\
x\
"""
ucode_str = \
u("""\
_\n\
x\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
f = Function('f')
expr = conjugate(f(x + 1))
ascii_str_1 = \
"""\
________\n\
f(1 + x)\
"""
ascii_str_2 = \
"""\
________\n\
f(x + 1)\
"""
ucode_str_1 = \
u("""\
________\n\
f(1 + x)\
""")
ucode_str_2 = \
u("""\
________\n\
f(x + 1)\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = f(x)
ascii_str = \
"""\
f(x)\
"""
ucode_str = \
u("""\
f(x)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = f(x, y)
ascii_str = \
"""\
f(x, y)\
"""
ucode_str = \
u("""\
f(x, y)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = f(x/(y + 1), y)
ascii_str_1 = \
"""\
/ x \\\n\
f|-----, y|\n\
\\1 + y /\
"""
ascii_str_2 = \
"""\
/ x \\\n\
f|-----, y|\n\
\\y + 1 /\
"""
ucode_str_1 = \
u("""\
⎛ x ⎞\n\
f⎜─────, y⎟\n\
⎝1 + y ⎠\
""")
ucode_str_2 = \
u("""\
⎛ x ⎞\n\
f⎜─────, y⎟\n\
⎝y + 1 ⎠\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = f(x**x**x**x**x**x)
ascii_str = \
"""\
/ / / / / x\\\\\\\\\\
| | | | \\x /||||
| | | \\x /|||
| | \\x /||
| \\x /|
f\\x /\
"""
ucode_str = \
u("""\
⎛ ⎛ ⎛ ⎛ ⎛ x⎞⎞⎞⎞⎞
⎜ ⎜ ⎜ ⎜ ⎝x ⎠⎟⎟⎟⎟
⎜ ⎜ ⎜ ⎝x ⎠⎟⎟⎟
⎜ ⎜ ⎝x ⎠⎟⎟
⎜ ⎝x ⎠⎟
f⎝x ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = sin(x)**2
ascii_str = \
"""\
2 \n\
sin (x)\
"""
ucode_str = \
u("""\
2 \n\
sin (x)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = conjugate(a + b*I)
ascii_str = \
"""\
_ _\n\
a - I*b\
"""
ucode_str = \
u("""\
_ _\n\
a - ⅈ⋅b\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = conjugate(exp(a + b*I))
ascii_str = \
"""\
_ _\n\
a - I*b\n\
e \
"""
ucode_str = \
u("""\
_ _\n\
a - ⅈ⋅b\n\
ℯ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = conjugate( f(1 + conjugate(f(x))) )
ascii_str_1 = \
"""\
___________\n\
/ ____\\\n\
f\\1 + f(x)/\
"""
ascii_str_2 = \
"""\
___________\n\
/____ \\\n\
f\\f(x) + 1/\
"""
ucode_str_1 = \
u("""\
___________\n\
⎛ ____⎞\n\
f⎝1 + f(x)⎠\
""")
ucode_str_2 = \
u("""\
___________\n\
⎛____ ⎞\n\
f⎝f(x) + 1⎠\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = f(x/(y + 1), y)
ascii_str_1 = \
"""\
/ x \\\n\
f|-----, y|\n\
\\1 + y /\
"""
ascii_str_2 = \
"""\
/ x \\\n\
f|-----, y|\n\
\\y + 1 /\
"""
ucode_str_1 = \
u("""\
⎛ x ⎞\n\
f⎜─────, y⎟\n\
⎝1 + y ⎠\
""")
ucode_str_2 = \
u("""\
⎛ x ⎞\n\
f⎜─────, y⎟\n\
⎝y + 1 ⎠\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = floor(1 / (y - floor(x)))
ascii_str = \
"""\
/ 1 \\\n\
floor|------------|\n\
\y - floor(x)/\
"""
ucode_str = \
u("""\
⎢ 1 ⎥\n\
⎢───────⎥\n\
⎣y - ⌊x⌋⎦\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = ceiling(1 / (y - ceiling(x)))
ascii_str = \
"""\
/ 1 \\\n\
ceiling|--------------|\n\
\y - ceiling(x)/\
"""
ucode_str = \
u("""\
⎡ 1 ⎤\n\
⎢───────⎥\n\
⎢y - ⌈x⌉⎥\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = euler(n)
ascii_str = \
"""\
E \n\
n\
"""
ucode_str = \
u("""\
E \n\
n\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = euler(1/(1 + 1/(1 + 1/n)))
ascii_str = \
"""\
E \n\
1 \n\
---------\n\
1 \n\
1 + -----\n\
1\n\
1 + -\n\
n\
"""
ucode_str = \
u("""\
E \n\
1 \n\
─────────\n\
1 \n\
1 + ─────\n\
1\n\
1 + ─\n\
n\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_sqrt():
expr = sqrt(2)
ascii_str = \
"""\
___\n\
\/ 2 \
"""
ucode_str = \
u("√2")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = 2**Rational(1, 3)
ascii_str = \
"""\
3 ___\n\
\/ 2 \
"""
ucode_str = \
u("""\
3 ___\n\
╲╱ 2 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = 2**Rational(1, 1000)
ascii_str = \
"""\
1000___\n\
\/ 2 \
"""
ucode_str = \
u("""\
1000___\n\
╲╱ 2 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = sqrt(x**2 + 1)
ascii_str = \
"""\
________\n\
/ 2 \n\
\/ x + 1 \
"""
ucode_str = \
u("""\
________\n\
╱ 2 \n\
╲╱ x + 1 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (1 + sqrt(5))**Rational(1, 3)
ascii_str = \
"""\
___________\n\
3 / ___ \n\
\/ 1 + \/ 5 \
"""
ucode_str = \
u("""\
3 ________\n\
╲╱ 1 + √5 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = 2**(1/x)
ascii_str = \
"""\
x ___\n\
\/ 2 \
"""
ucode_str = \
u("""\
x ___\n\
╲╱ 2 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = sqrt(2 + pi)
ascii_str = \
"""\
________\n\
\/ 2 + pi \
"""
ucode_str = \
u("""\
_______\n\
╲╱ 2 + π \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (2 + (
1 + x**2)/(2 + x))**Rational(1, 4) + (1 + x**Rational(1, 1000))/sqrt(3 + x**2)
ascii_str = \
"""\
____________ \n\
/ 2 1000___ \n\
/ x + 1 \/ x + 1\n\
4 / 2 + ------ + -----------\n\
\/ x + 2 ________\n\
/ 2 \n\
\/ x + 3 \
"""
ucode_str = \
u("""\
____________ \n\
╱ 2 1000___ \n\
╱ x + 1 ╲╱ x + 1\n\
4 ╱ 2 + ────── + ───────────\n\
╲╱ x + 2 ________\n\
╱ 2 \n\
╲╱ x + 3 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_sqrt_char_knob():
# See PR #9234.
expr = sqrt(2)
ucode_str1 = \
u("""\
___\n\
╲╱ 2 \
""")
ucode_str2 = \
u("√2")
assert xpretty(expr, use_unicode=True,
use_unicode_sqrt_char=False) == ucode_str1
assert xpretty(expr, use_unicode=True,
use_unicode_sqrt_char=True) == ucode_str2
def test_pretty_sqrt_longsymbol_no_sqrt_char():
# Do not use unicode sqrt char for long symbols (see PR #9234).
expr = sqrt(Symbol('C1'))
ucode_str = \
u("""\
____\n\
╲╱ C₁ \
""")
assert upretty(expr) == ucode_str
def test_pretty_KroneckerDelta():
x, y = symbols("x, y")
expr = KroneckerDelta(x, y)
ascii_str = \
"""\
d \n\
x,y\
"""
ucode_str = \
u("""\
δ \n\
x,y\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_product():
n, m, k, l = symbols('n m k l')
f = symbols('f', cls=Function)
expr = Product(f((n/3)**2), (n, k**2, l))
unicode_str = \
u("""\
l \n\
┬────────┬ \n\
│ │ ⎛ 2⎞\n\
│ │ ⎜n ⎟\n\
│ │ f⎜──⎟\n\
│ │ ⎝9 ⎠\n\
│ │ \n\
2 \n\
n = k """)
ascii_str = \
"""\
l \n\
__________ \n\
| | / 2\\\n\
| | |n |\n\
| | f|--|\n\
| | \9 /\n\
| | \n\
2 \n\
n = k """
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
expr = Product(f((n/3)**2), (n, k**2, l), (l, 1, m))
unicode_str = \
u("""\
m l \n\
┬────────┬ ┬────────┬ \n\
│ │ │ │ ⎛ 2⎞\n\
│ │ │ │ ⎜n ⎟\n\
│ │ │ │ f⎜──⎟\n\
│ │ │ │ ⎝9 ⎠\n\
│ │ │ │ \n\
l = 1 2 \n\
n = k """)
ascii_str = \
"""\
m l \n\
__________ __________ \n\
| | | | / 2\\\n\
| | | | |n |\n\
| | | | f|--|\n\
| | | | \9 /\n\
| | | | \n\
l = 1 2 \n\
n = k """
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
def test_pretty_lambda():
# S.IdentityFunction is a special case
expr = Lambda(y, y)
assert pretty(expr) == "x -> x"
assert upretty(expr) == u("x ↦ x")
expr = Lambda(x, x+1)
assert pretty(expr) == "x -> x + 1"
assert upretty(expr) == u("x ↦ x + 1")
expr = Lambda(x, x**2)
ascii_str = \
"""\
2\n\
x -> x \
"""
ucode_str = \
u("""\
2\n\
x ↦ x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Lambda(x, x**2)**2
ascii_str = \
"""\
2
/ 2\\ \n\
\\x -> x / \
"""
ucode_str = \
u("""\
2
⎛ 2⎞ \n\
⎝x ↦ x ⎠ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Lambda((x, y), x)
ascii_str = "(x, y) -> x"
ucode_str = u("(x, y) ↦ x")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Lambda((x, y), x**2)
ascii_str = \
"""\
2\n\
(x, y) -> x \
"""
ucode_str = \
u("""\
2\n\
(x, y) ↦ x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_order():
expr = O(1)
ascii_str = \
"""\
O(1)\
"""
ucode_str = \
u("""\
O(1)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = O(1/x)
ascii_str = \
"""\
/1\\\n\
O|-|\n\
\\x/\
"""
ucode_str = \
u("""\
⎛1⎞\n\
O⎜─⎟\n\
⎝x⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = O(x**2 + y**2)
ascii_str = \
"""\
/ 2 2 \\\n\
O\\x + y ; (x, y) -> (0, 0)/\
"""
ucode_str = \
u("""\
⎛ 2 2 ⎞\n\
O⎝x + y ; (x, y) → (0, 0)⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = O(1, (x, oo))
ascii_str = \
"""\
O(1; x -> oo)\
"""
ucode_str = \
u("""\
O(1; x → ∞)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = O(1/x, (x, oo))
ascii_str = \
"""\
/1 \\\n\
O|-; x -> oo|\n\
\\x /\
"""
ucode_str = \
u("""\
⎛1 ⎞\n\
O⎜─; x → ∞⎟\n\
⎝x ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = O(x**2 + y**2, (x, oo), (y, oo))
ascii_str = \
"""\
/ 2 2 \\\n\
O\\x + y ; (x, y) -> (oo, oo)/\
"""
ucode_str = \
u("""\
⎛ 2 2 ⎞\n\
O⎝x + y ; (x, y) → (∞, ∞)⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_derivatives():
# Simple
expr = Derivative(log(x), x, evaluate=False)
ascii_str = \
"""\
d \n\
--(log(x))\n\
dx \
"""
ucode_str = \
u("""\
d \n\
──(log(x))\n\
dx \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Derivative(log(x), x, evaluate=False) + x
ascii_str_1 = \
"""\
d \n\
x + --(log(x))\n\
dx \
"""
ascii_str_2 = \
"""\
d \n\
--(log(x)) + x\n\
dx \
"""
ucode_str_1 = \
u("""\
d \n\
x + ──(log(x))\n\
dx \
""")
ucode_str_2 = \
u("""\
d \n\
──(log(x)) + x\n\
dx \
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
# basic partial derivatives
expr = Derivative(log(x + y) + x, x)
ascii_str_1 = \
"""\
d \n\
--(log(x + y) + x)\n\
dx \
"""
ascii_str_2 = \
"""\
d \n\
--(x + log(x + y))\n\
dx \
"""
ucode_str_1 = \
u("""\
∂ \n\
──(log(x + y) + x)\n\
∂x \
""")
ucode_str_2 = \
u("""\
∂ \n\
──(x + log(x + y))\n\
∂x \
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2], upretty(expr)
# Multiple symbols
expr = Derivative(log(x) + x**2, x, y)
ascii_str_1 = \
"""\
2 \n\
d / 2\\\n\
-----\log(x) + x /\n\
dy dx \
"""
ascii_str_2 = \
"""\
2 \n\
d / 2 \\\n\
-----\\x + log(x)/\n\
dy dx \
"""
ucode_str_1 = \
u("""\
2 \n\
d ⎛ 2⎞\n\
─────⎝log(x) + x ⎠\n\
dy dx \
""")
ucode_str_2 = \
u("""\
2 \n\
d ⎛ 2 ⎞\n\
─────⎝x + log(x)⎠\n\
dy dx \
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = Derivative(2*x*y, y, x) + x**2
ascii_str_1 = \
"""\
2 \n\
d 2\n\
-----(2*x*y) + x \n\
dx dy \
"""
ascii_str_2 = \
"""\
2 \n\
2 d \n\
x + -----(2*x*y)\n\
dx dy \
"""
ucode_str_1 = \
u("""\
2 \n\
∂ 2\n\
─────(2⋅x⋅y) + x \n\
∂x ∂y \
""")
ucode_str_2 = \
u("""\
2 \n\
2 ∂ \n\
x + ─────(2⋅x⋅y)\n\
∂x ∂y \
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = Derivative(2*x*y, x, x)
ascii_str = \
"""\
2 \n\
d \n\
---(2*x*y)\n\
2 \n\
dx \
"""
ucode_str = \
u("""\
2 \n\
∂ \n\
───(2⋅x⋅y)\n\
2 \n\
∂x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Derivative(2*x*y, x, 17)
ascii_str = \
"""\
17 \n\
d \n\
----(2*x*y)\n\
17 \n\
dx \
"""
ucode_str = \
u("""\
17 \n\
∂ \n\
────(2⋅x⋅y)\n\
17 \n\
∂x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Derivative(2*x*y, x, x, y)
ascii_str = \
"""\
3 \n\
d \n\
------(2*x*y)\n\
2 \n\
dy dx \
"""
ucode_str = \
u("""\
3 \n\
∂ \n\
──────(2⋅x⋅y)\n\
2 \n\
∂y ∂x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
# Greek letters
alpha = Symbol('alpha')
beta = Function('beta')
expr = beta(alpha).diff(alpha)
ascii_str = \
"""\
d \n\
------(beta(alpha))\n\
dalpha \
"""
ucode_str = \
u("""\
d \n\
──(β(α))\n\
dα \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_integrals():
expr = Integral(log(x), x)
ascii_str = \
"""\
/ \n\
| \n\
| log(x) dx\n\
| \n\
/ \
"""
ucode_str = \
u("""\
⌠ \n\
⎮ log(x) dx\n\
⌡ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral(x**2, x)
ascii_str = \
"""\
/ \n\
| \n\
| 2 \n\
| x dx\n\
| \n\
/ \
"""
ucode_str = \
u("""\
⌠ \n\
⎮ 2 \n\
⎮ x dx\n\
⌡ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral((sin(x))**2 / (tan(x))**2)
ascii_str = \
"""\
/ \n\
| \n\
| 2 \n\
| sin (x) \n\
| ------- dx\n\
| 2 \n\
| tan (x) \n\
| \n\
/ \
"""
ucode_str = \
u("""\
⌠ \n\
⎮ 2 \n\
⎮ sin (x) \n\
⎮ ─────── dx\n\
⎮ 2 \n\
⎮ tan (x) \n\
⌡ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral(x**(2**x), x)
ascii_str = \
"""\
/ \n\
| \n\
| / x\ \n\
| \\2 / \n\
| x dx\n\
| \n\
/ \
"""
ucode_str = \
u("""\
⌠ \n\
⎮ ⎛ x⎞ \n\
⎮ ⎝2 ⎠ \n\
⎮ x dx\n\
⌡ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral(x**2, (x, 1, 2))
ascii_str = \
"""\
2 \n\
/ \n\
| \n\
| 2 \n\
| x dx\n\
| \n\
/ \n\
1 \
"""
ucode_str = \
u("""\
2 \n\
⌠ \n\
⎮ 2 \n\
⎮ x dx\n\
⌡ \n\
1 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral(x**2, (x, Rational(1, 2), 10))
ascii_str = \
"""\
10 \n\
/ \n\
| \n\
| 2 \n\
| x dx\n\
| \n\
/ \n\
1/2 \
"""
ucode_str = \
u("""\
10 \n\
⌠ \n\
⎮ 2 \n\
⎮ x dx\n\
⌡ \n\
1/2 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral(x**2*y**2, x, y)
ascii_str = \
"""\
/ / \n\
| | \n\
| | 2 2 \n\
| | x *y dx dy\n\
| | \n\
/ / \
"""
ucode_str = \
u("""\
⌠ ⌠ \n\
⎮ ⎮ 2 2 \n\
⎮ ⎮ x ⋅y dx dy\n\
⌡ ⌡ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral(sin(th)/cos(ph), (th, 0, pi), (ph, 0, 2*pi))
ascii_str = \
"""\
2*pi pi \n\
/ / \n\
| | \n\
| | sin(theta) \n\
| | ---------- d(theta) d(phi)\n\
| | cos(phi) \n\
| | \n\
/ / \n\
0 0 \
"""
ucode_str = \
u("""\
2⋅π π \n\
⌠ ⌠ \n\
⎮ ⎮ sin(θ) \n\
⎮ ⎮ ────── dθ dφ\n\
⎮ ⎮ cos(φ) \n\
⌡ ⌡ \n\
0 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_matrix():
# Empty Matrix
expr = Matrix()
ascii_str = "[]"
unicode_str = "[]"
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
expr = Matrix(2, 0, lambda i, j: 0)
ascii_str = "[]"
unicode_str = "[]"
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
expr = Matrix(0, 2, lambda i, j: 0)
ascii_str = "[]"
unicode_str = "[]"
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
expr = Matrix([[x**2 + 1, 1], [y, x + y]])
ascii_str_1 = \
"""\
[ 2 ]
[1 + x 1 ]
[ ]
[ y x + y]\
"""
ascii_str_2 = \
"""\
[ 2 ]
[x + 1 1 ]
[ ]
[ y x + y]\
"""
ucode_str_1 = \
u("""\
⎡ 2 ⎤
⎢1 + x 1 ⎥
⎢ ⎥
⎣ y x + y⎦\
""")
ucode_str_2 = \
u("""\
⎡ 2 ⎤
⎢x + 1 1 ⎥
⎢ ⎥
⎣ y x + y⎦\
""")
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = Matrix([[x/y, y, th], [0, exp(I*k*ph), 1]])
ascii_str = \
"""\
[x ]
[- y theta]
[y ]
[ ]
[ I*k*phi ]
[0 e 1 ]\
"""
ucode_str = \
u("""\
⎡x ⎤
⎢─ y θ⎥
⎢y ⎥
⎢ ⎥
⎢ ⅈ⋅k⋅φ ⎥
⎣0 ℯ 1⎦\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_Adjoint():
X = MatrixSymbol('X', 2, 2)
Y = MatrixSymbol('Y', 2, 2)
assert pretty(Adjoint(X)) == " +\nX "
assert pretty(Adjoint(X + Y)) == " +\n(X + Y) "
assert pretty(Adjoint(X) + Adjoint(Y)) == " + +\nX + Y "
assert pretty(Adjoint(X*Y)) == " +\n(X*Y) "
assert pretty(Adjoint(Y)*Adjoint(X)) == " + +\nY *X "
assert pretty(Adjoint(X**2)) == " +\n/ 2\\ \n\\X / "
assert pretty(Adjoint(X)**2) == " 2\n/ +\\ \n\\X / "
assert pretty(Adjoint(Inverse(X))) == " +\n/ -1\\ \n\\X / "
assert pretty(Inverse(Adjoint(X))) == " -1\n/ +\\ \n\\X / "
assert pretty(Adjoint(Transpose(X))) == " +\n/ T\\ \n\\X / "
assert pretty(Transpose(Adjoint(X))) == " T\n/ +\\ \n\\X / "
assert upretty(Adjoint(X)) == u(" †\nX ")
assert upretty(Adjoint(X + Y)) == u(" †\n(X + Y) ")
assert upretty(Adjoint(X) + Adjoint(Y)) == u(" † †\nX + Y ")
assert upretty(Adjoint(X*Y)) == u(" †\n(X⋅Y) ")
assert upretty(Adjoint(Y)*Adjoint(X)) == u(" † †\nY ⋅X ")
assert upretty(Adjoint(X**2)) == \
u(" †\n⎛ 2⎞ \n⎝X ⎠ ")
assert upretty(Adjoint(X)**2) == \
u(" 2\n⎛ †⎞ \n⎝X ⎠ ")
assert upretty(Adjoint(Inverse(X))) == \
u(" †\n⎛ -1⎞ \n⎝X ⎠ ")
assert upretty(Inverse(Adjoint(X))) == \
u(" -1\n⎛ †⎞ \n⎝X ⎠ ")
assert upretty(Adjoint(Transpose(X))) == \
u(" †\n⎛ T⎞ \n⎝X ⎠ ")
assert upretty(Transpose(Adjoint(X))) == \
u(" T\n⎛ †⎞ \n⎝X ⎠ ")
def test_pretty_Trace_issue_9044():
X = Matrix([[1, 2], [3, 4]])
Y = Matrix([[2, 4], [6, 8]])
ascii_str_1 = \
"""\
/[1 2]\\
tr|[ ]|
\[3 4]/\
"""
ucode_str_1 = \
u("""\
⎛⎡1 2⎤⎞
tr⎜⎢ ⎥⎟
⎝⎣3 4⎦⎠\
""")
ascii_str_2 = \
"""\
/[1 2]\ /[2 4]\\
tr|[ ]| + tr|[ ]|
\[3 4]/ \[6 8]/\
"""
ucode_str_2 = \
u("""\
⎛⎡1 2⎤⎞ ⎛⎡2 4⎤⎞
tr⎜⎢ ⎥⎟ + tr⎜⎢ ⎥⎟
⎝⎣3 4⎦⎠ ⎝⎣6 8⎦⎠\
""")
assert pretty(Trace(X)) == ascii_str_1
assert upretty(Trace(X)) == ucode_str_1
assert pretty(Trace(X) + Trace(Y)) == ascii_str_2
assert upretty(Trace(X) + Trace(Y)) == ucode_str_2
def test_MatrixExpressions():
n = Symbol('n', integer=True)
X = MatrixSymbol('X', n, n)
assert pretty(X) == upretty(X) == "X"
Y = X[1:2:3, 4:5:6]
ascii_str = ucode_str = "X[1:3, 4:6]"
assert pretty(Y) == ascii_str
assert upretty(Y) == ucode_str
Z = X[1:10:2]
ascii_str = ucode_str = "X[1:10:2, :n]"
assert pretty(Z) == ascii_str
assert upretty(Z) == ucode_str
def test_pretty_dotproduct():
from sympy.matrices import Matrix, MatrixSymbol
from sympy.matrices.expressions.dotproduct import DotProduct
n = symbols("n", integer=True)
A = MatrixSymbol('A', n, 1)
B = MatrixSymbol('B', n, 1)
C = Matrix(1, 3, [1, 2, 3])
D = Matrix(1, 3, [1, 3, 4])
assert pretty(DotProduct(A, B)) == u("A*B")
assert pretty(DotProduct(C, D)) == u("[1 2 3]*[1 3 4]")
assert upretty(DotProduct(A, B)) == u("A⋅B")
assert upretty(DotProduct(C, D)) == u("[1 2 3]⋅[1 3 4]")
def test_pretty_piecewise():
expr = Piecewise((x, x < 1), (x**2, True))
ascii_str = \
"""\
/x for x < 1\n\
| \n\
< 2 \n\
|x otherwise\n\
\ \
"""
ucode_str = \
u("""\
⎧x for x < 1\n\
⎪ \n\
⎨ 2 \n\
⎪x otherwise\n\
⎩ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -Piecewise((x, x < 1), (x**2, True))
ascii_str = \
"""\
//x for x < 1\\\n\
|| |\n\
-|< 2 |\n\
||x otherwise|\n\
\\\\ /\
"""
ucode_str = \
u("""\
⎛⎧x for x < 1⎞\n\
⎜⎪ ⎟\n\
-⎜⎨ 2 ⎟\n\
⎜⎪x otherwise⎟\n\
⎝⎩ ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = x + Piecewise((x, x > 0), (y, True)) + Piecewise((x/y, x < 2),
(y**2, x > 2), (1, True)) + 1
ascii_str = \
"""\
//x \ \n\
||- for x < 2| \n\
||y | \n\
//x for x > 0\ || | \n\
x + |< | + |< 2 | + 1\n\
\\\\y otherwise/ ||y for x > 2| \n\
|| | \n\
||1 otherwise| \n\
\\\\ / \
"""
ucode_str = \
u("""\
⎛⎧x ⎞ \n\
⎜⎪─ for x < 2⎟ \n\
⎜⎪y ⎟ \n\
⎛⎧x for x > 0⎞ ⎜⎪ ⎟ \n\
x + ⎜⎨ ⎟ + ⎜⎨ 2 ⎟ + 1\n\
⎝⎩y otherwise⎠ ⎜⎪y for x > 2⎟ \n\
⎜⎪ ⎟ \n\
⎜⎪1 otherwise⎟ \n\
⎝⎩ ⎠ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = x - Piecewise((x, x > 0), (y, True)) + Piecewise((x/y, x < 2),
(y**2, x > 2), (1, True)) + 1
ascii_str = \
"""\
//x \ \n\
||- for x < 2| \n\
||y | \n\
//x for x > 0\ || | \n\
x - |< | + |< 2 | + 1\n\
\\\\y otherwise/ ||y for x > 2| \n\
|| | \n\
||1 otherwise| \n\
\\\\ / \
"""
ucode_str = \
u("""\
⎛⎧x ⎞ \n\
⎜⎪─ for x < 2⎟ \n\
⎜⎪y ⎟ \n\
⎛⎧x for x > 0⎞ ⎜⎪ ⎟ \n\
x - ⎜⎨ ⎟ + ⎜⎨ 2 ⎟ + 1\n\
⎝⎩y otherwise⎠ ⎜⎪y for x > 2⎟ \n\
⎜⎪ ⎟ \n\
⎜⎪1 otherwise⎟ \n\
⎝⎩ ⎠ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = x*Piecewise((x, x > 0), (y, True))
ascii_str = \
"""\
//x for x > 0\\\n\
x*|< |\n\
\\\\y otherwise/\
"""
ucode_str = \
u("""\
⎛⎧x for x > 0⎞\n\
x⋅⎜⎨ ⎟\n\
⎝⎩y otherwise⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Piecewise((x, x > 0), (y, True))*Piecewise((x/y, x < 2), (y**2, x >
2), (1, True))
ascii_str = \
"""\
//x \\\n\
||- for x < 2|\n\
||y |\n\
//x for x > 0\ || |\n\
|< |*|< 2 |\n\
\\\\y otherwise/ ||y for x > 2|\n\
|| |\n\
||1 otherwise|\n\
\\\\ /\
"""
ucode_str = \
u("""\
⎛⎧x ⎞\n\
⎜⎪─ for x < 2⎟\n\
⎜⎪y ⎟\n\
⎛⎧x for x > 0⎞ ⎜⎪ ⎟\n\
⎜⎨ ⎟⋅⎜⎨ 2 ⎟\n\
⎝⎩y otherwise⎠ ⎜⎪y for x > 2⎟\n\
⎜⎪ ⎟\n\
⎜⎪1 otherwise⎟\n\
⎝⎩ ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -Piecewise((x, x > 0), (y, True))*Piecewise((x/y, x < 2), (y**2, x
> 2), (1, True))
ascii_str = \
"""\
//x \\\n\
||- for x < 2|\n\
||y |\n\
//x for x > 0\ || |\n\
-|< |*|< 2 |\n\
\\\\y otherwise/ ||y for x > 2|\n\
|| |\n\
||1 otherwise|\n\
\\\\ /\
"""
ucode_str = \
u("""\
⎛⎧x ⎞\n\
⎜⎪─ for x < 2⎟\n\
⎜⎪y ⎟\n\
⎛⎧x for x > 0⎞ ⎜⎪ ⎟\n\
-⎜⎨ ⎟⋅⎜⎨ 2 ⎟\n\
⎝⎩y otherwise⎠ ⎜⎪y for x > 2⎟\n\
⎜⎪ ⎟\n\
⎜⎪1 otherwise⎟\n\
⎝⎩ ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Piecewise((0, Abs(1/y) < 1), (1, Abs(y) < 1), (y*meijerg(((2, 1),
()), ((), (1, 0)), 1/y), True))
ascii_str = \
"""\
/ |1| \n\
| 0 for |-| < 1\n\
| |y| \n\
| \n\
< 1 for |y| < 1\n\
| \n\
| __0, 2 /2, 1 | 1\ \n\
|y*/__ | | -| otherwise \n\
\ \\_|2, 2 \ 1, 0 | y/ \
"""
ucode_str = \
u("""\
⎧ │1│ \n\
⎪ 0 for │─│ < 1\n\
⎪ │y│ \n\
⎪ \n\
⎨ 1 for │y│ < 1\n\
⎪ \n\
⎪ ╭─╮0, 2 ⎛2, 1 │ 1⎞ \n\
⎪y⋅│╶┐ ⎜ │ ─⎟ otherwise \n\
⎩ ╰─╯2, 2 ⎝ 1, 0 │ y⎠ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
# XXX: We have to use evaluate=False here because Piecewise._eval_power
# denests the power.
expr = Pow(Piecewise((x, x > 0), (y, True)), 2, evaluate=False)
ascii_str = \
"""\
2\n\
//x for x > 0\ \n\
|< | \n\
\\\\y otherwise/ \
"""
ucode_str = \
u("""\
2\n\
⎛⎧x for x > 0⎞ \n\
⎜⎨ ⎟ \n\
⎝⎩y otherwise⎠ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_seq():
expr = ()
ascii_str = \
"""\
()\
"""
ucode_str = \
u("""\
()\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = []
ascii_str = \
"""\
[]\
"""
ucode_str = \
u("""\
[]\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = {}
expr_2 = {}
ascii_str = \
"""\
{}\
"""
ucode_str = \
u("""\
{}\
""")
assert pretty(expr) == ascii_str
assert pretty(expr_2) == ascii_str
assert upretty(expr) == ucode_str
assert upretty(expr_2) == ucode_str
expr = (1/x,)
ascii_str = \
"""\
1 \n\
(-,)\n\
x \
"""
ucode_str = \
u("""\
⎛1 ⎞\n\
⎜─,⎟\n\
⎝x ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = [x**2, 1/x, x, y, sin(th)**2/cos(ph)**2]
ascii_str = \
"""\
2 \n\
2 1 sin (theta) \n\
[x , -, x, y, -----------]\n\
x 2 \n\
cos (phi) \
"""
ucode_str = \
u("""\
⎡ 2 ⎤\n\
⎢ 2 1 sin (θ)⎥\n\
⎢x , ─, x, y, ───────⎥\n\
⎢ x 2 ⎥\n\
⎣ cos (φ)⎦\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x**2, 1/x, x, y, sin(th)**2/cos(ph)**2)
ascii_str = \
"""\
2 \n\
2 1 sin (theta) \n\
(x , -, x, y, -----------)\n\
x 2 \n\
cos (phi) \
"""
ucode_str = \
u("""\
⎛ 2 ⎞\n\
⎜ 2 1 sin (θ)⎟\n\
⎜x , ─, x, y, ───────⎟\n\
⎜ x 2 ⎟\n\
⎝ cos (φ)⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Tuple(x**2, 1/x, x, y, sin(th)**2/cos(ph)**2)
ascii_str = \
"""\
2 \n\
2 1 sin (theta) \n\
(x , -, x, y, -----------)\n\
x 2 \n\
cos (phi) \
"""
ucode_str = \
u("""\
⎛ 2 ⎞\n\
⎜ 2 1 sin (θ)⎟\n\
⎜x , ─, x, y, ───────⎟\n\
⎜ x 2 ⎟\n\
⎝ cos (φ)⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = {x: sin(x)}
expr_2 = Dict({x: sin(x)})
ascii_str = \
"""\
{x: sin(x)}\
"""
ucode_str = \
u("""\
{x: sin(x)}\
""")
assert pretty(expr) == ascii_str
assert pretty(expr_2) == ascii_str
assert upretty(expr) == ucode_str
assert upretty(expr_2) == ucode_str
expr = {1/x: 1/y, x: sin(x)**2}
expr_2 = Dict({1/x: 1/y, x: sin(x)**2})
ascii_str = \
"""\
1 1 2 \n\
{-: -, x: sin (x)}\n\
x y \
"""
ucode_str = \
u("""\
⎧1 1 2 ⎫\n\
⎨─: ─, x: sin (x)⎬\n\
⎩x y ⎭\
""")
assert pretty(expr) == ascii_str
assert pretty(expr_2) == ascii_str
assert upretty(expr) == ucode_str
assert upretty(expr_2) == ucode_str
# There used to be a bug with pretty-printing sequences of even height.
expr = [x**2]
ascii_str = \
"""\
2 \n\
[x ]\
"""
ucode_str = \
u("""\
⎡ 2⎤\n\
⎣x ⎦\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x**2,)
ascii_str = \
"""\
2 \n\
(x ,)\
"""
ucode_str = \
u("""\
⎛ 2 ⎞\n\
⎝x ,⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Tuple(x**2)
ascii_str = \
"""\
2 \n\
(x ,)\
"""
ucode_str = \
u("""\
⎛ 2 ⎞\n\
⎝x ,⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = {x**2: 1}
expr_2 = Dict({x**2: 1})
ascii_str = \
"""\
2 \n\
{x : 1}\
"""
ucode_str = \
u("""\
⎧ 2 ⎫\n\
⎨x : 1⎬\n\
⎩ ⎭\
""")
assert pretty(expr) == ascii_str
assert pretty(expr_2) == ascii_str
assert upretty(expr) == ucode_str
assert upretty(expr_2) == ucode_str
def test_any_object_in_sequence():
# Cf. issue 5306
b1 = Basic()
b2 = Basic(Basic())
expr = [b2, b1]
assert pretty(expr) == "[Basic(Basic()), Basic()]"
assert upretty(expr) == u("[Basic(Basic()), Basic()]")
expr = set([b2, b1])
assert pretty(expr) == "set([Basic(), Basic(Basic())])"
assert upretty(expr) == u("set([Basic(), Basic(Basic())])")
expr = {b2: b1, b1: b2}
expr2 = Dict({b2: b1, b1: b2})
assert pretty(expr) == "{Basic(): Basic(Basic()), Basic(Basic()): Basic()}"
assert pretty(
expr2) == "{Basic(): Basic(Basic()), Basic(Basic()): Basic()}"
assert upretty(
expr) == u("{Basic(): Basic(Basic()), Basic(Basic()): Basic()}")
assert upretty(
expr2) == u("{Basic(): Basic(Basic()), Basic(Basic()): Basic()}")
def test_pretty_sets():
s = FiniteSet
assert pretty(s(*[x*y, x**2])) == \
"""\
2 \n\
{x , x*y}\
"""
assert pretty(s(*range(1, 6))) == "{1, 2, 3, 4, 5}"
assert pretty(s(*range(1, 13))) == "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}"
for s in (frozenset, set):
assert pretty(s([x*y, x**2])) == \
"""\
%s 2 \n\
%s([x , x*y])\
""" % (" " * len(s.__name__), s.__name__)
assert pretty(s(range(1, 6))) == "%s([1, 2, 3, 4, 5])" % s.__name__
assert pretty(s(range(1, 13))) == \
"%s([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])" % s.__name__
assert pretty(Range(0, 3, 1)) == '{0, 1, 2}'
ascii_str = '{0, 1, ..., 29}'
ucode_str = u('{0, 1, …, 29}')
assert pretty(Range(0, 30, 1)) == ascii_str
assert upretty(Range(0, 30, 1)) == ucode_str
ascii_str = '{0, 2, ..., oo}'
ucode_str = u('{0, 2, …, ∞}')
assert pretty(Range(0, oo, 2)) == ascii_str
assert upretty(Range(0, oo, 2)) == ucode_str
ascii_str = '{-oo, ..., -3, -2}'
ucode_str = u('{-∞, …, -3, -2}')
assert pretty(Range(-2, -oo, -1)) == ascii_str
assert upretty(Range(-2, -oo, -1)) == ucode_str
def test_pretty_ConditionSet():
from sympy import ConditionSet
ascii_str = '{x | x in (-oo, oo) and sin(x) = 0}'
ucode_str = u('{x | x ∊ ℝ ∧ sin(x) = 0}')
assert pretty(ConditionSet(x, Eq(sin(x), 0), S.Reals)) == ascii_str
assert upretty(ConditionSet(x, Eq(sin(x), 0), S.Reals)) == ucode_str
assert pretty(ConditionSet(x, Contains(x, S.Reals, evaluate=False), FiniteSet(1))) == '{1}'
assert upretty(ConditionSet(x, Contains(x, S.Reals, evaluate=False), FiniteSet(1))) == u('{1}')
assert pretty(ConditionSet(x, And(x > 1, x < -1), FiniteSet(1, 2, 3))) == "EmptySet()"
assert upretty(ConditionSet(x, And(x > 1, x < -1), FiniteSet(1, 2, 3))) == u("∅")
assert pretty(ConditionSet(x, Or(x > 1, x < -1), FiniteSet(1, 2))) == '{2}'
assert upretty(ConditionSet(x, Or(x > 1, x < -1), FiniteSet(1, 2))) == u('{2}')
def test_pretty_ComplexRegion():
from sympy import ComplexRegion
ucode_str = u('{x + y⋅ⅈ | x, y ∊ [3, 5] × [4, 6]}')
assert upretty(ComplexRegion(Interval(3, 5)*Interval(4, 6))) == ucode_str
ucode_str = u('{r⋅(ⅈ⋅sin(θ) + cos(θ)) | r, θ ∊ [0, 1] × [0, 2⋅π)}')
assert upretty(ComplexRegion(Interval(0, 1)*Interval(0, 2*pi), polar=True)) == ucode_str
def test_pretty_Union_issue_10414():
a, b = Interval(2, 3), Interval(4, 7)
ucode_str = u('[2, 3] ∪ [4, 7]')
ascii_str = '[2, 3] U [4, 7]'
assert upretty(Union(a, b)) == ucode_str
assert pretty(Union(a, b)) == ascii_str
def test_pretty_Intersection_issue_10414():
x, y, z, w = symbols('x, y, z, w')
a, b = Interval(x, y), Interval(z, w)
ucode_str = u('[x, y] ∩ [z, w]')
ascii_str = '[x, y] n [z, w]'
assert upretty(Intersection(a, b)) == ucode_str
assert pretty(Intersection(a, b)) == ascii_str
def test_ProductSet_paranthesis():
ucode_str = u('([4, 7] × {1, 2}) ∪ ([2, 3] × [4, 7])')
a, b, c = Interval(2, 3), Interval(4, 7), Interval(1, 9)
assert upretty(Union(a*b, b*FiniteSet(1, 2))) == ucode_str
def test_ProductSet_prod_char_issue_10413():
ascii_str = '[2, 3] x [4, 7]'
ucode_str = u('[2, 3] × [4, 7]')
a, b = Interval(2, 3), Interval(4, 7)
assert pretty(a*b) == ascii_str
assert upretty(a*b) == ucode_str
def test_pretty_sequences():
s1 = SeqFormula(a**2, (0, oo))
s2 = SeqPer((1, 2))
ascii_str = '[0, 1, 4, 9, ...]'
ucode_str = u('[0, 1, 4, 9, …]')
assert pretty(s1) == ascii_str
assert upretty(s1) == ucode_str
ascii_str = '[1, 2, 1, 2, ...]'
ucode_str = u('[1, 2, 1, 2, …]')
assert pretty(s2) == ascii_str
assert upretty(s2) == ucode_str
s3 = SeqFormula(a**2, (0, 2))
s4 = SeqPer((1, 2), (0, 2))
ascii_str = '[0, 1, 4]'
ucode_str = u('[0, 1, 4]')
assert pretty(s3) == ascii_str
assert upretty(s3) == ucode_str
ascii_str = '[1, 2, 1]'
ucode_str = u('[1, 2, 1]')
assert pretty(s4) == ascii_str
assert upretty(s4) == ucode_str
s5 = SeqFormula(a**2, (-oo, 0))
s6 = SeqPer((1, 2), (-oo, 0))
ascii_str = '[..., 9, 4, 1, 0]'
ucode_str = u('[…, 9, 4, 1, 0]')
assert pretty(s5) == ascii_str
assert upretty(s5) == ucode_str
ascii_str = '[..., 2, 1, 2, 1]'
ucode_str = u('[…, 2, 1, 2, 1]')
assert pretty(s6) == ascii_str
assert upretty(s6) == ucode_str
ascii_str = '[1, 3, 5, 11, ...]'
ucode_str = u('[1, 3, 5, 11, …]')
assert pretty(SeqAdd(s1, s2)) == ascii_str
assert upretty(SeqAdd(s1, s2)) == ucode_str
ascii_str = '[1, 3, 5]'
ucode_str = u('[1, 3, 5]')
assert pretty(SeqAdd(s3, s4)) == ascii_str
assert upretty(SeqAdd(s3, s4)) == ucode_str
ascii_str = '[..., 11, 5, 3, 1]'
ucode_str = u('[…, 11, 5, 3, 1]')
assert pretty(SeqAdd(s5, s6)) == ascii_str
assert upretty(SeqAdd(s5, s6)) == ucode_str
ascii_str = '[0, 2, 4, 18, ...]'
ucode_str = u('[0, 2, 4, 18, …]')
assert pretty(SeqMul(s1, s2)) == ascii_str
assert upretty(SeqMul(s1, s2)) == ucode_str
ascii_str = '[0, 2, 4]'
ucode_str = u('[0, 2, 4]')
assert pretty(SeqMul(s3, s4)) == ascii_str
assert upretty(SeqMul(s3, s4)) == ucode_str
ascii_str = '[..., 18, 4, 2, 0]'
ucode_str = u('[…, 18, 4, 2, 0]')
assert pretty(SeqMul(s5, s6)) == ascii_str
assert upretty(SeqMul(s5, s6)) == ucode_str
def test_pretty_FourierSeries():
f = fourier_series(x, (x, -pi, pi))
ascii_str = \
"""\
2*sin(3*x) \n\
2*sin(x) - sin(2*x) + ---------- + ...\n\
3 \
"""
ucode_str = \
u("""\
2⋅sin(3⋅x) \n\
2⋅sin(x) - sin(2⋅x) + ────────── + …\n\
3 \
""")
assert pretty(f) == ascii_str
assert upretty(f) == ucode_str
def test_pretty_FormalPowerSeries():
f = fps(log(1 + x))
ascii_str = \
"""\
2 3 4 5 \n\
x x x x / 6\\\n\
x - -- + -- - -- + -- + O\\x /\n\
2 3 4 5 \
"""
ucode_str = \
u("""\
2 3 4 5 \n\
x x x x ⎛ 6⎞\n\
x - ── + ── - ── + ── + O⎝x ⎠\n\
2 3 4 5 \
""")
assert pretty(f) == ascii_str
assert upretty(f) == ucode_str
def test_pretty_limits():
expr = Limit(x, x, oo)
ascii_str = \
"""\
lim x\n\
x->oo \
"""
ucode_str = \
u("""\
lim x\n\
x─→∞ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Limit(x**2, x, 0)
ascii_str = \
"""\
2\n\
lim x \n\
x->0+ \
"""
ucode_str = \
u("""\
2\n\
lim x \n\
x─→0⁺ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Limit(1/x, x, 0)
ascii_str = \
"""\
1\n\
lim -\n\
x->0+x\
"""
ucode_str = \
u("""\
1\n\
lim ─\n\
x─→0⁺x\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Limit(sin(x)/x, x, 0)
ascii_str = \
"""\
sin(x)\n\
lim ------\n\
x->0+ x \
"""
ucode_str = \
u("""\
sin(x)\n\
lim ──────\n\
x─→0⁺ x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Limit(sin(x)/x, x, 0, "-")
ascii_str = \
"""\
sin(x)\n\
lim ------\n\
x->0- x \
"""
ucode_str = \
u("""\
sin(x)\n\
lim ──────\n\
x─→0⁻ x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Limit(x + sin(x), x, 0)
ascii_str = \
"""\
lim (x + sin(x))\n\
x->0+ \
"""
ucode_str = \
u("""\
lim (x + sin(x))\n\
x─→0⁺ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_ComplexRootOf():
expr = rootof(x**5 + 11*x - 2, 0)
ascii_str = \
"""\
/ 5 \\\n\
CRootOf\\x + 11*x - 2, 0/\
"""
ucode_str = \
u("""\
⎛ 5 ⎞\n\
CRootOf⎝x + 11⋅x - 2, 0⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_RootSum():
expr = RootSum(x**5 + 11*x - 2, auto=False)
ascii_str = \
"""\
/ 5 \\\n\
RootSum\\x + 11*x - 2/\
"""
ucode_str = \
u("""\
⎛ 5 ⎞\n\
RootSum⎝x + 11⋅x - 2⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = RootSum(x**5 + 11*x - 2, Lambda(z, exp(z)))
ascii_str = \
"""\
/ 5 z\\\n\
RootSum\\x + 11*x - 2, z -> e /\
"""
ucode_str = \
u("""\
⎛ 5 z⎞\n\
RootSum⎝x + 11⋅x - 2, z ↦ ℯ ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_GroebnerBasis():
expr = groebner([], x, y)
ascii_str = \
"""\
GroebnerBasis([], x, y, domain=ZZ, order=lex)\
"""
ucode_str = \
u("""\
GroebnerBasis([], x, y, domain=ℤ, order=lex)\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1]
expr = groebner(F, x, y, order='grlex')
ascii_str = \
"""\
/[ 2 2 ] \\\n\
GroebnerBasis\\[x - x - 3*y + 1, y - 2*x + y - 1], x, y, domain=ZZ, order=grlex/\
"""
ucode_str = \
u("""\
⎛⎡ 2 2 ⎤ ⎞\n\
GroebnerBasis⎝⎣x - x - 3⋅y + 1, y - 2⋅x + y - 1⎦, x, y, domain=ℤ, order=grlex⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = expr.fglm('lex')
ascii_str = \
"""\
/[ 2 4 3 2 ] \\\n\
GroebnerBasis\\[2*x - y - y + 1, y + 2*y - 3*y - 16*y + 7], x, y, domain=ZZ, order=lex/\
"""
ucode_str = \
u("""\
⎛⎡ 2 4 3 2 ⎤ ⎞\n\
GroebnerBasis⎝⎣2⋅x - y - y + 1, y + 2⋅y - 3⋅y - 16⋅y + 7⎦, x, y, domain=ℤ, order=lex⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_Boolean():
expr = Not(x, evaluate=False)
assert pretty(expr) == "Not(x)"
assert upretty(expr) == u("¬x")
expr = And(x, y)
assert pretty(expr) == "And(x, y)"
assert upretty(expr) == u("x ∧ y")
expr = Or(x, y)
assert pretty(expr) == "Or(x, y)"
assert upretty(expr) == u("x ∨ y")
syms = symbols('a:f')
expr = And(*syms)
assert pretty(expr) == "And(a, b, c, d, e, f)"
assert upretty(expr) == u("a ∧ b ∧ c ∧ d ∧ e ∧ f")
expr = Or(*syms)
assert pretty(expr) == "Or(a, b, c, d, e, f)"
assert upretty(expr) == u("a ∨ b ∨ c ∨ d ∨ e ∨ f")
expr = Xor(x, y, evaluate=False)
assert pretty(expr) == "Xor(x, y)"
assert upretty(expr) == u("x ⊻ y")
expr = Nand(x, y, evaluate=False)
assert pretty(expr) == "Nand(x, y)"
assert upretty(expr) == u("x ⊼ y")
expr = Nor(x, y, evaluate=False)
assert pretty(expr) == "Nor(x, y)"
assert upretty(expr) == u("x ⊽ y")
expr = Implies(x, y, evaluate=False)
assert pretty(expr) == "Implies(x, y)"
assert upretty(expr) == u("x → y")
# don't sort args
expr = Implies(y, x, evaluate=False)
assert pretty(expr) == "Implies(y, x)"
assert upretty(expr) == u("y → x")
expr = Equivalent(x, y, evaluate=False)
assert pretty(expr) == "Equivalent(x, y)"
assert upretty(expr) == u("x ≡ y")
expr = Equivalent(y, x, evaluate=False)
assert pretty(expr) == "Equivalent(x, y)"
assert upretty(expr) == u("x ≡ y")
def test_pretty_Domain():
expr = FF(23)
assert pretty(expr) == "GF(23)"
assert upretty(expr) == u("ℤ₂₃")
expr = ZZ
assert pretty(expr) == "ZZ"
assert upretty(expr) == u("ℤ")
expr = QQ
assert pretty(expr) == "QQ"
assert upretty(expr) == u("ℚ")
expr = RR
assert pretty(expr) == "RR"
assert upretty(expr) == u("ℝ")
expr = QQ[x]
assert pretty(expr) == "QQ[x]"
assert upretty(expr) == u("ℚ[x]")
expr = QQ[x, y]
assert pretty(expr) == "QQ[x, y]"
assert upretty(expr) == u("ℚ[x, y]")
expr = ZZ.frac_field(x)
assert pretty(expr) == "ZZ(x)"
assert upretty(expr) == u("ℤ(x)")
expr = ZZ.frac_field(x, y)
assert pretty(expr) == "ZZ(x, y)"
assert upretty(expr) == u("ℤ(x, y)")
expr = QQ.poly_ring(x, y, order=grlex)
assert pretty(expr) == "QQ[x, y, order=grlex]"
assert upretty(expr) == u("ℚ[x, y, order=grlex]")
expr = QQ.poly_ring(x, y, order=ilex)
assert pretty(expr) == "QQ[x, y, order=ilex]"
assert upretty(expr) == u("ℚ[x, y, order=ilex]")
def test_pretty_prec():
assert xpretty(S("0.3"), full_prec=True, wrap_line=False) == "0.300000000000000"
assert xpretty(S("0.3"), full_prec="auto", wrap_line=False) == "0.300000000000000"
assert xpretty(S("0.3"), full_prec=False, wrap_line=False) == "0.3"
assert xpretty(S("0.3")*x, full_prec=True, use_unicode=False, wrap_line=False) in [
"0.300000000000000*x",
"x*0.300000000000000"
]
assert xpretty(S("0.3")*x, full_prec="auto", use_unicode=False, wrap_line=False) in [
"0.3*x",
"x*0.3"
]
assert xpretty(S("0.3")*x, full_prec=False, use_unicode=False, wrap_line=False) in [
"0.3*x",
"x*0.3"
]
def test_pprint():
import sys
from sympy.core.compatibility import StringIO
fd = StringIO()
sso = sys.stdout
sys.stdout = fd
try:
pprint(pi, use_unicode=False, wrap_line=False)
finally:
sys.stdout = sso
assert fd.getvalue() == 'pi\n'
def test_pretty_class():
"""Test that the printer dispatcher correctly handles classes."""
class C:
pass # C has no .__class__ and this was causing problems
class D(object):
pass
assert pretty( C ) == str( C )
assert pretty( D ) == str( D )
def test_pretty_no_wrap_line():
huge_expr = 0
for i in range(20):
huge_expr += i*sin(i + x)
assert xpretty(huge_expr ).find('\n') != -1
assert xpretty(huge_expr, wrap_line=False).find('\n') == -1
def test_settings():
raises(TypeError, lambda: pretty(S(4), method="garbage"))
def test_pretty_sum():
from sympy.abc import x, a, b, k, m, n
expr = Sum(k**k, (k, 0, n))
ascii_str = \
"""\
n \n\
___ \n\
\\ ` \n\
\\ k\n\
/ k \n\
/__, \n\
k = 0 \
"""
ucode_str = \
u("""\
n \n\
___ \n\
╲ \n\
╲ k\n\
╱ k \n\
╱ \n\
‾‾‾ \n\
k = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(k**(Integral(x**n, (x, -oo, oo))), (k, 0, n**n))
ascii_str = \
"""\
n \n\
n \n\
______ \n\
\\ ` \n\
\\ oo \n\
\\ / \n\
\\ | \n\
\\ | n \n\
) | x dx\n\
/ | \n\
/ / \n\
/ -oo \n\
/ k \n\
/_____, \n\
k = 0 \
"""
ucode_str = \
u("""\
n \n\
n \n\
______ \n\
╲ \n\
╲ ∞ \n\
╲ ⌠ \n\
╲ ⎮ n \n\
╲ ⎮ x dx\n\
╱ ⌡ \n\
╱ -∞ \n\
╱ k \n\
╱ \n\
╱ \n\
‾‾‾‾‾‾ \n\
k = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(k**(
Integral(x**n, (x, -oo, oo))), (k, 0, Integral(x**x, (x, -oo, oo))))
ascii_str = \
"""\
oo \n\
/ \n\
| \n\
| x \n\
| x dx \n\
| \n\
/ \n\
-oo \n\
______ \n\
\\ ` \n\
\\ oo \n\
\\ / \n\
\\ | \n\
\\ | n \n\
) | x dx\n\
/ | \n\
/ / \n\
/ -oo \n\
/ k \n\
/_____, \n\
k = 0 \
"""
ucode_str = \
u("""\
∞ \n\
⌠ \n\
⎮ x \n\
⎮ x dx \n\
⌡ \n\
-∞ \n\
______ \n\
╲ \n\
╲ ∞ \n\
╲ ⌠ \n\
╲ ⎮ n \n\
╲ ⎮ x dx\n\
╱ ⌡ \n\
╱ -∞ \n\
╱ k \n\
╱ \n\
╱ \n\
‾‾‾‾‾‾ \n\
k = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(k**(Integral(x**n, (x, -oo, oo))), (
k, x + n + x**2 + n**2 + (x/n) + (1/x), Integral(x**x, (x, -oo, oo))))
ascii_str = \
"""\
oo \n\
/ \n\
| \n\
| x \n\
| x dx \n\
| \n\
/ \n\
-oo \n\
______ \n\
\ ` \n\
\ oo \n\
\ / \n\
\ | \n\
\ | n \n\
) | x dx\n\
/ | \n\
/ / \n\
/ -oo \n\
/ k \n\
/_____, \n\
2 2 1 x \n\
k = n + n + x + x + - + - \n\
x n \
"""
ucode_str = \
u("""\
∞ \n\
⌠ \n\
⎮ x \n\
⎮ x dx \n\
⌡ \n\
-∞ \n\
______ \n\
╲ \n\
╲ ∞ \n\
╲ ⌠ \n\
╲ ⎮ n \n\
╲ ⎮ x dx\n\
╱ ⌡ \n\
╱ -∞ \n\
╱ k \n\
╱ \n\
╱ \n\
‾‾‾‾‾‾ \n\
2 2 1 x \n\
k = n + n + x + x + ─ + ─ \n\
x n \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(k**(
Integral(x**n, (x, -oo, oo))), (k, 0, x + n + x**2 + n**2 + (x/n) + (1/x)))
ascii_str = \
"""\
2 2 1 x \n\
n + n + x + x + - + - \n\
x n \n\
______ \n\
\ ` \n\
\ oo \n\
\ / \n\
\ | \n\
\ | n \n\
) | x dx\n\
/ | \n\
/ / \n\
/ -oo \n\
/ k \n\
/_____, \n\
k = 0 \
"""
ucode_str = \
u("""\
2 2 1 x \n\
n + n + x + x + ─ + ─ \n\
x n \n\
______ \n\
╲ \n\
╲ ∞ \n\
╲ ⌠ \n\
╲ ⎮ n \n\
╲ ⎮ x dx\n\
╱ ⌡ \n\
╱ -∞ \n\
╱ k \n\
╱ \n\
╱ \n\
‾‾‾‾‾‾ \n\
k = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(x, (x, 0, oo))
ascii_str = \
"""\
oo \n\
__ \n\
\\ ` \n\
) x\n\
/_, \n\
x = 0 \
"""
ucode_str = \
u("""\
∞ \n\
___ \n\
╲ \n\
╲ x\n\
╱ \n\
╱ \n\
‾‾‾ \n\
x = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(x**2, (x, 0, oo))
ascii_str = \
u("""\
oo \n\
___ \n\
\\ ` \n\
\\ 2\n\
/ x \n\
/__, \n\
x = 0 \
""")
ucode_str = \
u("""\
∞ \n\
___ \n\
╲ \n\
╲ 2\n\
╱ x \n\
╱ \n\
‾‾‾ \n\
x = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(x/2, (x, 0, oo))
ascii_str = \
"""\
oo \n\
___ \n\
\\ ` \n\
\\ x\n\
) -\n\
/ 2\n\
/__, \n\
x = 0 \
"""
ucode_str = \
u("""\
∞ \n\
____ \n\
╲ \n\
╲ x\n\
╲ ─\n\
╱ 2\n\
╱ \n\
╱ \n\
‾‾‾‾ \n\
x = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(x**3/2, (x, 0, oo))
ascii_str = \
"""\
oo \n\
____ \n\
\\ ` \n\
\\ 3\n\
\\ x \n\
/ --\n\
/ 2 \n\
/___, \n\
x = 0 \
"""
ucode_str = \
u("""\
∞ \n\
____ \n\
╲ \n\
╲ 3\n\
╲ x \n\
╱ ──\n\
╱ 2 \n\
╱ \n\
‾‾‾‾ \n\
x = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum((x**3*y**(x/2))**n, (x, 0, oo))
ascii_str = \
"""\
oo \n\
____ \n\
\\ ` \n\
\\ n\n\
\\ / x\\ \n\
) | -| \n\
/ | 3 2| \n\
/ \\x *y / \n\
/___, \n\
x = 0 \
"""
ucode_str = \
u("""\
∞ \n\
_____ \n\
╲ \n\
╲ n\n\
╲ ⎛ x⎞ \n\
╲ ⎜ ─⎟ \n\
╱ ⎜ 3 2⎟ \n\
╱ ⎝x ⋅y ⎠ \n\
╱ \n\
╱ \n\
‾‾‾‾‾ \n\
x = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(1/x**2, (x, 0, oo))
ascii_str = \
"""\
oo \n\
____ \n\
\\ ` \n\
\\ 1 \n\
\\ --\n\
/ 2\n\
/ x \n\
/___, \n\
x = 0 \
"""
ucode_str = \
u("""\
∞ \n\
____ \n\
╲ \n\
╲ 1 \n\
╲ ──\n\
╱ 2\n\
╱ x \n\
╱ \n\
‾‾‾‾ \n\
x = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(1/y**(a/b), (x, 0, oo))
ascii_str = \
"""\
oo \n\
____ \n\
\\ ` \n\
\\ -a \n\
\\ ---\n\
/ b \n\
/ y \n\
/___, \n\
x = 0 \
"""
ucode_str = \
u("""\
∞ \n\
____ \n\
╲ \n\
╲ -a \n\
╲ ───\n\
╱ b \n\
╱ y \n\
╱ \n\
‾‾‾‾ \n\
x = 0 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Sum(1/y**(a/b), (x, 0, oo), (y, 1, 2))
ascii_str = \
"""\
2 oo \n\
____ ____ \n\
\\ ` \\ ` \n\
\\ \\ -a\n\
\\ \\ --\n\
/ / b \n\
/ / y \n\
/___, /___, \n\
y = 1 x = 0 \
"""
ucode_str = \
u("""\
2 ∞ \n\
____ ____ \n\
╲ ╲ \n\
╲ ╲ -a\n\
╲ ╲ ──\n\
╱ ╱ b \n\
╱ ╱ y \n\
╱ ╱ \n\
‾‾‾‾ ‾‾‾‾ \n\
y = 1 x = 0 \
""")
expr = Sum(1/(1 + 1/(
1 + 1/k)) + 1, (k, 111, 1 + 1/n), (k, 1/(1 + m), oo)) + 1/(1 + 1/k)
ascii_str = \
"""\
1 \n\
1 + - \n\
oo n \n\
_____ _____ \n\
\\ ` \\ ` \n\
\\ \\ / 1 \\ \n\
\\ \\ |1 + ---------| \n\
\\ \\ | 1 | 1 \n\
) ) | 1 + -----| + -----\n\
/ / | 1| 1\n\
/ / | 1 + -| 1 + -\n\
/ / \\ k/ k\n\
/____, /____, \n\
1 k = 111 \n\
k = ----- \n\
m + 1 \
"""
ucode_str = \
u("""\
1 \n\
1 + ─ \n\
∞ n \n\
______ ______ \n\
╲ ╲ \n\
╲ ╲ ⎛ 1 ⎞ \n\
╲ ╲ ⎜1 + ─────────⎟ \n\
╲ ╲ ⎜ 1 ⎟ \n\
╲ ╲ ⎜ 1 + ─────⎟ 1 \n\
╱ ╱ ⎜ 1⎟ + ─────\n\
╱ ╱ ⎜ 1 + ─⎟ 1\n\
╱ ╱ ⎝ k⎠ 1 + ─\n\
╱ ╱ k\n\
╱ ╱ \n\
‾‾‾‾‾‾ ‾‾‾‾‾‾ \n\
1 k = 111 \n\
k = ───── \n\
m + 1 \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_units():
expr = joule
ascii_str = \
"""\
2\n\
kg*m \n\
-----\n\
2 \n\
s \
"""
unicode_str = \
u("""\
2\n\
kg⋅m \n\
─────\n\
2 \n\
s \
""")
assert upretty(expr) == unicode_str
assert pretty(expr) == ascii_str
def test_pretty_Subs():
f = Function('f')
expr = Subs(f(x), x, ph**2)
ascii_str = \
"""\
(f(x))| 2\n\
|x=phi \
"""
unicode_str = \
u("""\
(f(x))│ 2\n\
│x=φ \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
expr = Subs(f(x).diff(x), x, 0)
ascii_str = \
"""\
/d \\| \n\
|--(f(x))|| \n\
\\dx /|x=0\
"""
unicode_str = \
u("""\
⎛d ⎞│ \n\
⎜──(f(x))⎟│ \n\
⎝dx ⎠│x=0\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
expr = Subs(f(x).diff(x)/y, (x, y), (0, Rational(1, 2)))
ascii_str = \
"""\
/d \\| \n\
|--(f(x))|| \n\
|dx || \n\
|--------|| \n\
\\ y /|x=0, y=1/2\
"""
unicode_str = \
u("""\
⎛d ⎞│ \n\
⎜──(f(x))⎟│ \n\
⎜dx ⎟│ \n\
⎜────────⎟│ \n\
⎝ y ⎠│x=0, y=1/2\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == unicode_str
def test_gammas():
assert upretty(lowergamma(x, y)) == u("γ(x, y)")
assert upretty(uppergamma(x, y)) == u("Γ(x, y)")
assert xpretty(gamma(x), use_unicode=True) == u('Γ(x)')
def test_hyper():
expr = hyper((), (), z)
ucode_str = \
u("""\
┌─ ⎛ │ ⎞\n\
├─ ⎜ │ z⎟\n\
0╵ 0 ⎝ │ ⎠\
""")
ascii_str = \
"""\
_ \n\
|_ / | \\\n\
| | | z|\n\
0 0 \\ | /\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = hyper((), (1,), x)
ucode_str = \
u("""\
┌─ ⎛ │ ⎞\n\
├─ ⎜ │ x⎟\n\
0╵ 1 ⎝1 │ ⎠\
""")
ascii_str = \
"""\
_ \n\
|_ / | \\\n\
| | | x|\n\
0 1 \\1 | /\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = hyper([2], [1], x)
ucode_str = \
u("""\
┌─ ⎛2 │ ⎞\n\
├─ ⎜ │ x⎟\n\
1╵ 1 ⎝1 │ ⎠\
""")
ascii_str = \
"""\
_ \n\
|_ /2 | \\\n\
| | | x|\n\
1 1 \\1 | /\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = hyper((pi/3, -2*k), (3, 4, 5, -3), x)
ucode_str = \
u("""\
⎛ π │ ⎞\n\
┌─ ⎜ ─, -2⋅k │ ⎟\n\
├─ ⎜ 3 │ x⎟\n\
2╵ 4 ⎜ │ ⎟\n\
⎝3, 4, 5, -3 │ ⎠\
""")
ascii_str = \
"""\
\n\
_ / pi | \\\n\
|_ | --, -2*k | |\n\
| | 3 | x|\n\
2 4 | | |\n\
\\3, 4, 5, -3 | /\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = hyper((pi, S('2/3'), -2*k), (3, 4, 5, -3), x**2)
ucode_str = \
u("""\
┌─ ⎛π, 2/3, -2⋅k │ 2⎞\n\
├─ ⎜ │ x ⎟\n\
3╵ 4 ⎝3, 4, 5, -3 │ ⎠\
""")
ascii_str = \
"""\
_ \n\
|_ /pi, 2/3, -2*k | 2\\\n\
| | | x |\n\
3 4 \\ 3, 4, 5, -3 | /\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = hyper([1, 2], [3, 4], 1/(1/(1/(1/x + 1) + 1) + 1))
ucode_str = \
u("""\
⎛ │ 1 ⎞\n\
⎜ │ ─────────────⎟\n\
⎜ │ 1 ⎟\n\
┌─ ⎜1, 2 │ 1 + ─────────⎟\n\
├─ ⎜ │ 1 ⎟\n\
2╵ 2 ⎜3, 4 │ 1 + ─────⎟\n\
⎜ │ 1⎟\n\
⎜ │ 1 + ─⎟\n\
⎝ │ x⎠\
""")
ascii_str = \
"""\
\n\
/ | 1 \\\n\
| | -------------|\n\
_ | | 1 |\n\
|_ |1, 2 | 1 + ---------|\n\
| | | 1 |\n\
2 2 |3, 4 | 1 + -----|\n\
| | 1|\n\
| | 1 + -|\n\
\\ | x/\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_meijerg():
expr = meijerg([pi, pi, x], [1], [0, 1], [1, 2, 3], z)
ucode_str = \
u("""\
╭─╮2, 3 ⎛π, π, x 1 │ ⎞\n\
│╶┐ ⎜ │ z⎟\n\
╰─╯4, 5 ⎝ 0, 1 1, 2, 3 │ ⎠\
""")
ascii_str = \
"""\
__2, 3 /pi, pi, x 1 | \\\n\
/__ | | z|\n\
\_|4, 5 \\ 0, 1 1, 2, 3 | /\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = meijerg([1, pi/7], [2, pi, 5], [], [], z**2)
ucode_str = \
u("""\
⎛ π │ ⎞\n\
╭─╮0, 2 ⎜1, ─ 2, π, 5 │ 2⎟\n\
│╶┐ ⎜ 7 │ z ⎟\n\
╰─╯5, 0 ⎜ │ ⎟\n\
⎝ │ ⎠\
""")
ascii_str = \
"""\
/ pi | \\\n\
__0, 2 |1, -- 2, pi, 5 | 2|\n\
/__ | 7 | z |\n\
\_|5, 0 | | |\n\
\\ | /\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
ucode_str = \
u("""\
╭─╮ 1, 10 ⎛1, 1, 1, 1, 1, 1, 1, 1, 1, 1 1 │ ⎞\n\
│╶┐ ⎜ │ z⎟\n\
╰─╯11, 2 ⎝ 1 1 │ ⎠\
""")
ascii_str = \
"""\
__ 1, 10 /1, 1, 1, 1, 1, 1, 1, 1, 1, 1 1 | \\\n\
/__ | | z|\n\
\_|11, 2 \\ 1 1 | /\
"""
expr = meijerg([1]*10, [1], [1], [1], z)
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = meijerg([1, 2, ], [4, 3], [3], [4, 5], 1/(1/(1/(1/x + 1) + 1) + 1))
ucode_str = \
u("""\
⎛ │ 1 ⎞\n\
⎜ │ ─────────────⎟\n\
⎜ │ 1 ⎟\n\
╭─╮1, 2 ⎜1, 2 4, 3 │ 1 + ─────────⎟\n\
│╶┐ ⎜ │ 1 ⎟\n\
╰─╯4, 3 ⎜ 3 4, 5 │ 1 + ─────⎟\n\
⎜ │ 1⎟\n\
⎜ │ 1 + ─⎟\n\
⎝ │ x⎠\
""")
ascii_str = \
"""\
/ | 1 \\\n\
| | -------------|\n\
| | 1 |\n\
__1, 2 |1, 2 4, 3 | 1 + ---------|\n\
/__ | | 1 |\n\
\_|4, 3 | 3 4, 5 | 1 + -----|\n\
| | 1|\n\
| | 1 + -|\n\
\\ | x/\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = Integral(expr, x)
ucode_str = \
u("""\
⌠ \n\
⎮ ⎛ │ 1 ⎞ \n\
⎮ ⎜ │ ─────────────⎟ \n\
⎮ ⎜ │ 1 ⎟ \n\
⎮ ╭─╮1, 2 ⎜1, 2 4, 3 │ 1 + ─────────⎟ \n\
⎮ │╶┐ ⎜ │ 1 ⎟ dx\n\
⎮ ╰─╯4, 3 ⎜ 3 4, 5 │ 1 + ─────⎟ \n\
⎮ ⎜ │ 1⎟ \n\
⎮ ⎜ │ 1 + ─⎟ \n\
⎮ ⎝ │ x⎠ \n\
⌡ \
""")
ascii_str = \
"""\
/ \n\
| \n\
| / | 1 \\ \n\
| | | -------------| \n\
| | | 1 | \n\
| __1, 2 |1, 2 4, 3 | 1 + ---------| \n\
| /__ | | 1 | dx\n\
| \_|4, 3 | 3 4, 5 | 1 + -----| \n\
| | | 1| \n\
| | | 1 + -| \n\
| \\ | x/ \n\
| \n\
/ \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_noncommutative():
A, B, C = symbols('A,B,C', commutative=False)
expr = A*B*C**-1
ascii_str = \
"""\
-1\n\
A*B*C \
"""
ucode_str = \
u("""\
-1\n\
A⋅B⋅C \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = C**-1*A*B
ascii_str = \
"""\
-1 \n\
C *A*B\
"""
ucode_str = \
u("""\
-1 \n\
C ⋅A⋅B\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = A*C**-1*B
ascii_str = \
"""\
-1 \n\
A*C *B\
"""
ucode_str = \
u("""\
-1 \n\
A⋅C ⋅B\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = A*C**-1*B/x
ascii_str = \
"""\
-1 \n\
A*C *B\n\
-------\n\
x \
"""
ucode_str = \
u("""\
-1 \n\
A⋅C ⋅B\n\
───────\n\
x \
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_special_functions():
x, y = symbols("x y")
# atan2
expr = atan2(y/sqrt(200), sqrt(x))
ascii_str = \
"""\
/ ___ \\\n\
|\\/ 2 *y ___|\n\
atan2|-------, \\/ x |\n\
\\ 20 /\
"""
ucode_str = \
u("""\
⎛√2⋅y ⎞\n\
atan2⎜────, √x⎟\n\
⎝ 20 ⎠\
""")
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_pretty_geometry():
e = Segment((0, 1), (0, 2))
assert pretty(e) == 'Segment(Point2D(0, 1), Point2D(0, 2))'
e = Ray((1, 1), angle=4.02*pi)
assert pretty(e) == 'Ray(Point2D(1, 1), Point2D(2, tan(pi/50) + 1))'
def test_expint():
expr = Ei(x)
string = 'Ei(x)'
assert pretty(expr) == string
assert upretty(expr) == string
expr = expint(1, z)
ucode_str = u("E₁(z)")
ascii_str = "expint(1, z)"
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
assert pretty(Shi(x)) == 'Shi(x)'
assert pretty(Si(x)) == 'Si(x)'
assert pretty(Ci(x)) == 'Ci(x)'
assert pretty(Chi(x)) == 'Chi(x)'
assert upretty(Shi(x)) == 'Shi(x)'
assert upretty(Si(x)) == 'Si(x)'
assert upretty(Ci(x)) == 'Ci(x)'
assert upretty(Chi(x)) == 'Chi(x)'
def test_elliptic_functions():
ascii_str = \
"""\
/ 1 \\\n\
K|-----|\n\
\z + 1/\
"""
ucode_str = \
u("""\
⎛ 1 ⎞\n\
K⎜─────⎟\n\
⎝z + 1⎠\
""")
expr = elliptic_k(1/(z + 1))
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
ascii_str = \
"""\
/ | 1 \\\n\
F|1|-----|\n\
\ |z + 1/\
"""
ucode_str = \
u("""\
⎛ │ 1 ⎞\n\
F⎜1│─────⎟\n\
⎝ │z + 1⎠\
""")
expr = elliptic_f(1, 1/(1 + z))
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
ascii_str = \
"""\
/ 1 \\\n\
E|-----|\n\
\z + 1/\
"""
ucode_str = \
u("""\
⎛ 1 ⎞\n\
E⎜─────⎟\n\
⎝z + 1⎠\
""")
expr = elliptic_e(1/(z + 1))
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
ascii_str = \
"""\
/ | 1 \\\n\
E|1|-----|\n\
\ |z + 1/\
"""
ucode_str = \
u("""\
⎛ │ 1 ⎞\n\
E⎜1│─────⎟\n\
⎝ │z + 1⎠\
""")
expr = elliptic_e(1, 1/(1 + z))
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
ascii_str = \
"""\
/ |4\\\n\
Pi|3|-|\n\
\ |x/\
"""
ucode_str = \
u("""\
⎛ │4⎞\n\
Π⎜3│─⎟\n\
⎝ │x⎠\
""")
expr = elliptic_pi(3, 4/x)
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
ascii_str = \
"""\
/ 4| \\\n\
Pi|3; -|6|\n\
\ x| /\
"""
ucode_str = \
u("""\
⎛ 4│ ⎞\n\
Π⎜3; ─│6⎟\n\
⎝ x│ ⎠\
""")
expr = elliptic_pi(3, 4/x, 6)
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_RandomDomain():
from sympy.stats import Normal, Die, Exponential, pspace, where
X = Normal('x1', 0, 1)
assert upretty(where(X > 0)) == u("Domain: 0 < x₁ ∧ x₁ < ∞")
D = Die('d1', 6)
assert upretty(where(D > 4)) == u('Domain: d₁ = 5 ∨ d₁ = 6')
A = Exponential('a', 1)
B = Exponential('b', 1)
assert upretty(pspace(Tuple(A, B)).domain) == \
u('Domain: 0 ≤ a ∧ 0 ≤ b ∧ a < ∞ ∧ b < ∞')
def test_PrettyPoly():
F = QQ.frac_field(x, y)
R = QQ.poly_ring(x, y)
expr = F.convert(x/(x + y))
assert pretty(expr) == "x/(x + y)"
assert upretty(expr) == u("x/(x + y)")
expr = R.convert(x + y)
assert pretty(expr) == "x + y"
assert upretty(expr) == u("x + y")
def test_issue_6285():
assert pretty(Pow(2, -5, evaluate=False)) == '1 \n--\n 5\n2 '
assert pretty(Pow(x, (1/pi))) == 'pi___\n\\/ x '
def test_issue_6359():
assert pretty(Integral(x**2, x)**2) == \
"""\
2
/ / \ \n\
| | | \n\
| | 2 | \n\
| | x dx| \n\
| | | \n\
\/ / \
"""
assert upretty(Integral(x**2, x)**2) == \
u("""\
2
⎛⌠ ⎞ \n\
⎜⎮ 2 ⎟ \n\
⎜⎮ x dx⎟ \n\
⎝⌡ ⎠ \
""")
assert pretty(Sum(x**2, (x, 0, 1))**2) == \
"""\
2
/ 1 \\ \n\
| ___ | \n\
| \\ ` | \n\
| \\ 2| \n\
| / x | \n\
| /__, | \n\
\\x = 0 / \
"""
assert upretty(Sum(x**2, (x, 0, 1))**2) == \
u("""\
2
⎛ 1 ⎞ \n\
⎜ ___ ⎟ \n\
⎜ ╲ ⎟ \n\
⎜ ╲ 2⎟ \n\
⎜ ╱ x ⎟ \n\
⎜ ╱ ⎟ \n\
⎜ ‾‾‾ ⎟ \n\
⎝x = 0 ⎠ \
""")
assert pretty(Product(x**2, (x, 1, 2))**2) == \
"""\
2
/ 2 \\ \n\
|______ | \n\
|| | 2| \n\
|| | x | \n\
|| | | \n\
\\x = 1 / \
"""
assert upretty(Product(x**2, (x, 1, 2))**2) == \
u("""\
2
⎛ 2 ⎞ \n\
⎜┬────┬ ⎟ \n\
⎜│ │ 2⎟ \n\
⎜│ │ x ⎟ \n\
⎜│ │ ⎟ \n\
⎝x = 1 ⎠ \
""")
f = Function('f')
assert pretty(Derivative(f(x), x)**2) == \
"""\
2
/d \\ \n\
|--(f(x))| \n\
\\dx / \
"""
assert upretty(Derivative(f(x), x)**2) == \
u("""\
2
⎛d ⎞ \n\
⎜──(f(x))⎟ \n\
⎝dx ⎠ \
""")
def test_issue_6739():
ascii_str = \
"""\
1 \n\
-----\n\
___\n\
\/ x \
"""
ucode_str = \
u("""\
1 \n\
──\n\
√x\
""")
assert pretty(1/sqrt(x)) == ascii_str
assert upretty(1/sqrt(x)) == ucode_str
def test_complicated_symbol_unchanged():
for symb_name in ["dexpr2_d1tau", "dexpr2^d1tau"]:
assert pretty(Symbol(symb_name)) == symb_name
def test_categories():
from sympy.categories import (Object, IdentityMorphism,
NamedMorphism, Category, Diagram, DiagramGrid)
A1 = Object("A1")
A2 = Object("A2")
A3 = Object("A3")
f1 = NamedMorphism(A1, A2, "f1")
f2 = NamedMorphism(A2, A3, "f2")
id_A1 = IdentityMorphism(A1)
K1 = Category("K1")
assert pretty(A1) == "A1"
assert upretty(A1) == u("A₁")
assert pretty(f1) == "f1:A1-->A2"
assert upretty(f1) == u("f₁:A₁——▶A₂")
assert pretty(id_A1) == "id:A1-->A1"
assert upretty(id_A1) == u("id:A₁——▶A₁")
assert pretty(f2*f1) == "f2*f1:A1-->A3"
assert upretty(f2*f1) == u("f₂∘f₁:A₁——▶A₃")
assert pretty(K1) == "K1"
assert upretty(K1) == u("K₁")
# Test how diagrams are printed.
d = Diagram()
assert pretty(d) == "EmptySet()"
assert upretty(d) == u("∅")
d = Diagram({f1: "unique", f2: S.EmptySet})
assert pretty(d) == "{f2*f1:A1-->A3: EmptySet(), id:A1-->A1: " \
"EmptySet(), id:A2-->A2: EmptySet(), id:A3-->A3: " \
"EmptySet(), f1:A1-->A2: {unique}, f2:A2-->A3: EmptySet()}"
assert upretty(d) == u("{f₂∘f₁:A₁——▶A₃: ∅, id:A₁——▶A₁: ∅, " \
"id:A₂——▶A₂: ∅, id:A₃——▶A₃: ∅, f₁:A₁——▶A₂: {unique}, f₂:A₂——▶A₃: ∅}")
d = Diagram({f1: "unique", f2: S.EmptySet}, {f2 * f1: "unique"})
assert pretty(d) == "{f2*f1:A1-->A3: EmptySet(), id:A1-->A1: " \
"EmptySet(), id:A2-->A2: EmptySet(), id:A3-->A3: " \
"EmptySet(), f1:A1-->A2: {unique}, f2:A2-->A3: EmptySet()}" \
" ==> {f2*f1:A1-->A3: {unique}}"
assert upretty(d) == u("{f₂∘f₁:A₁——▶A₃: ∅, id:A₁——▶A₁: ∅, id:A₂——▶A₂: " \
"∅, id:A₃——▶A₃: ∅, f₁:A₁——▶A₂: {unique}, f₂:A₂——▶A₃: ∅}" \
" ══▶ {f₂∘f₁:A₁——▶A₃: {unique}}")
grid = DiagramGrid(d)
assert pretty(grid) == "A1 A2\n \nA3 "
assert upretty(grid) == u("A₁ A₂\n \nA₃ ")
def test_PrettyModules():
R = QQ.old_poly_ring(x, y)
F = R.free_module(2)
M = F.submodule([x, y], [1, x**2])
ucode_str = \
u("""\
2\n\
ℚ[x, y] \
""")
ascii_str = \
"""\
2\n\
QQ[x, y] \
"""
assert upretty(F) == ucode_str
assert pretty(F) == ascii_str
ucode_str = \
u("""\
╱ ⎡ 2⎤╲\n\
╲[x, y], ⎣1, x ⎦╱\
""")
ascii_str = \
"""\
2 \n\
<[x, y], [1, x ]>\
"""
assert upretty(M) == ucode_str
assert pretty(M) == ascii_str
I = R.ideal(x**2, y)
ucode_str = \
u("""\
╱ 2 ╲\n\
╲x , y╱\
""")
ascii_str = \
"""\
2 \n\
<x , y>\
"""
assert upretty(I) == ucode_str
assert pretty(I) == ascii_str
Q = F / M
ucode_str = \
u("""\
2 \n\
ℚ[x, y] \n\
─────────────────\n\
╱ ⎡ 2⎤╲\n\
╲[x, y], ⎣1, x ⎦╱\
""")
ascii_str = \
"""\
2 \n\
QQ[x, y] \n\
-----------------\n\
2 \n\
<[x, y], [1, x ]>\
"""
assert upretty(Q) == ucode_str
assert pretty(Q) == ascii_str
ucode_str = \
u("""\
╱⎡ 3⎤ ╲\n\
│⎢ x ⎥ ╱ ⎡ 2⎤╲ ╱ ⎡ 2⎤╲│\n\
│⎢1, ──⎥ + ╲[x, y], ⎣1, x ⎦╱, [2, y] + ╲[x, y], ⎣1, x ⎦╱│\n\
╲⎣ 2 ⎦ ╱\
""")
ascii_str = \
"""\
3 \n\
x 2 2 \n\
<[1, --] + <[x, y], [1, x ]>, [2, y] + <[x, y], [1, x ]>>\n\
2 \
"""
def test_QuotientRing():
R = QQ.old_poly_ring(x)/[x**2 + 1]
ucode_str = \
u("""\
ℚ[x] \n\
────────\n\
╱ 2 ╲\n\
╲x + 1╱\
""")
ascii_str = \
"""\
QQ[x] \n\
--------\n\
2 \n\
<x + 1>\
"""
assert upretty(R) == ucode_str
assert pretty(R) == ascii_str
ucode_str = \
u("""\
╱ 2 ╲\n\
1 + ╲x + 1╱\
""")
ascii_str = \
"""\
2 \n\
1 + <x + 1>\
"""
assert upretty(R.one) == ucode_str
assert pretty(R.one) == ascii_str
def test_Homomorphism():
from sympy.polys.agca import homomorphism
R = QQ.old_poly_ring(x)
expr = homomorphism(R.free_module(1), R.free_module(1), [0])
ucode_str = \
u("""\
1 1\n\
[0] : ℚ[x] ──> ℚ[x] \
""")
ascii_str = \
"""\
1 1\n\
[0] : QQ[x] --> QQ[x] \
"""
assert upretty(expr) == ucode_str
assert pretty(expr) == ascii_str
expr = homomorphism(R.free_module(2), R.free_module(2), [0, 0])
ucode_str = \
u("""\
⎡0 0⎤ 2 2\n\
⎢ ⎥ : ℚ[x] ──> ℚ[x] \n\
⎣0 0⎦ \
""")
ascii_str = \
"""\
[0 0] 2 2\n\
[ ] : QQ[x] --> QQ[x] \n\
[0 0] \
"""
assert upretty(expr) == ucode_str
assert pretty(expr) == ascii_str
expr = homomorphism(R.free_module(1), R.free_module(1) / [[x]], [0])
ucode_str = \
u("""\
1\n\
1 ℚ[x] \n\
[0] : ℚ[x] ──> ─────\n\
<[x]>\
""")
ascii_str = \
"""\
1\n\
1 QQ[x] \n\
[0] : QQ[x] --> ------\n\
<[x]> \
"""
assert upretty(expr) == ucode_str
assert pretty(expr) == ascii_str
def test_Tr():
A, B = symbols('A B', commutative=False)
t = Tr(A*B)
assert pretty(t) == r'Tr(A*B)'
assert upretty(t) == u('Tr(A⋅B)')
def test_pretty_Add():
eq = Mul(-2, x - 2, evaluate=False) + 5
assert pretty(eq) == '-2*(x - 2) + 5'
def test_issue_7179():
assert upretty(Not(Equivalent(x, y))) == u('x ≢ y')
assert upretty(Not(Implies(x, y))) == u('x ↛ y')
def test_issue_7180():
assert upretty(Equivalent(x, y)) == u('x ≡ y')
def test_pretty_Complement():
assert pretty(S.Reals - S.Naturals) == '(-oo, oo) \ Naturals()'
assert upretty(S.Reals - S.Naturals) == u('ℝ \ ℕ')
assert pretty(S.Reals - S.Naturals0) == '(-oo, oo) \ Naturals0()'
assert upretty(S.Reals - S.Naturals0) == u('ℝ \ ℕ₀')
def test_pretty_SymmetricDifference():
from sympy import SymmetricDifference, Interval
from sympy.utilities.pytest import raises
assert upretty(SymmetricDifference(Interval(2,3), Interval(3,5), \
evaluate = False)) == u('[2, 3] ∆ [3, 5]')
with raises(NotImplementedError):
pretty(SymmetricDifference(Interval(2,3), Interval(3,5), evaluate = False))
def test_pretty_Contains():
assert pretty(Contains(x, S.Integers)) == 'Contains(x, Integers())'
assert upretty(Contains(x, S.Integers)) == u('x ∈ ℤ')
def test_issue_8292():
from sympy.core import sympify
e = sympify('((x+x**4)/(x-1))-(2*(x-1)**4/(x-1)**4)', evaluate=False)
ucode_str = \
u("""\
4 4 \n\
2⋅(x - 1) x + x\n\
- ────────── + ──────\n\
4 x - 1 \n\
(x - 1) \
""")
ascii_str = \
"""\
4 4 \n\
2*(x - 1) x + x\n\
- ---------- + ------\n\
4 x - 1 \n\
(x - 1) \
"""
assert pretty(e) == ascii_str
assert upretty(e) == ucode_str
def test_issue_4335():
expr = -y(x).diff(x)
ucode_str = \
u("""\
d \n\
-──(y(x))\n\
dx \
""")
ascii_str = \
"""\
d \n\
- --(y(x))\n\
dx \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_issue_8344():
from sympy.core import sympify
e = sympify('2*x*y**2/1**2 + 1', evaluate=False)
ucode_str = \
u("""\
2 \n\
2⋅x⋅y \n\
────── + 1\n\
2 \n\
1 \
""")
assert upretty(e) == ucode_str
def test_issue_6324():
x = Pow(2, 3, evaluate=False)
y = Pow(10, -2, evaluate=False)
e = Mul(x, y, evaluate=False)
ucode_str = \
u("""\
3\n\
2 \n\
───\n\
2\n\
10 \
""")
assert upretty(e) == ucode_str
def test_issue_7927():
e = sin(x/2)**cos(x/2)
ucode_str = \
u("""\
⎛x⎞\n\
cos⎜─⎟\n\
⎝2⎠\n\
⎛ ⎛x⎞⎞ \n\
⎜sin⎜─⎟⎟ \n\
⎝ ⎝2⎠⎠ \
""")
assert upretty(e) == ucode_str
e = sin(x)**(S(11)/13)
ucode_str = \
u("""\
11\n\
──\n\
13\n\
(sin(x)) \
""")
assert upretty(e) == ucode_str
def test_issue_6134():
from sympy.abc import lamda, phi, t
e = lamda*x*Integral(phi(t)*pi*sin(pi*t), (t, 0, 1)) + lamda*x**2*Integral(phi(t)*2*pi*sin(2*pi*t), (t, 0, 1))
ucode_str = \
u("""\
1 1 \n\
2 ⌠ ⌠ \n\
λ⋅x ⋅⎮ 2⋅π⋅φ(t)⋅sin(2⋅π⋅t) dt + λ⋅x⋅⎮ π⋅φ(t)⋅sin(π⋅t) dt\n\
⌡ ⌡ \n\
0 0 \
""")
assert upretty(e) == ucode_str
def test_issue_9877():
ucode_str1 = u('(2, 3) ∪ ([1, 2] \ {x})')
a, b, c = Interval(2, 3, True, True), Interval(1, 2), FiniteSet(x)
assert upretty(Union(a, Complement(b, c))) == ucode_str1
ucode_str2 = u('{x} ∩ {y} ∩ ({z} \ [1, 2])')
d, e, f, g = FiniteSet(x), FiniteSet(y), FiniteSet(z), Interval(1, 2)
assert upretty(Intersection(d, e, Complement(f, g))) == ucode_str2
| 20.271186 | 114 | 0.407618 |
c58cf1573ea394f3f7f6f92e6017b6f5931cd078 | 1,156 | py | Python | account/migrations/0003_likes.py | AngleMAXIN/nomooc | 0c06b8af405b8254c242b34e85b7cba99c8f5737 | [
"MIT"
]
| 1 | 2019-12-04T03:20:16.000Z | 2019-12-04T03:20:16.000Z | account/migrations/0003_likes.py | AngleMAXIN/NoMooc | 0c06b8af405b8254c242b34e85b7cba99c8f5737 | [
"MIT"
]
| null | null | null | account/migrations/0003_likes.py | AngleMAXIN/NoMooc | 0c06b8af405b8254c242b34e85b7cba99c8f5737 | [
"MIT"
]
| null | null | null | # Generated by Django 2.1.7 on 2020-01-10 10:12
import django.utils.timezone
from django.db import migrations, models
import utils.models
class Migration(migrations.Migration):
dependencies = [
('account', '0002_adminoperationrecord'),
]
operations = [
migrations.CreateModel(
name='Likes',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('is_like', models.BooleanField(default=True, verbose_name='是否点赞')),
('liked_id', models.PositiveIntegerField(default=0, verbose_name='被点赞对象的id')),
('user_id', models.PositiveIntegerField(default=0, verbose_name='用户id')),
('liked_obj', utils.models.MyCharField(default='', max_length=8, verbose_name='点赞的对象')),
('created_time', models.DateTimeField(auto_now_add=True, verbose_name='点赞时间')),
('up_time', models.DateTimeField(default=django.utils.timezone.now, verbose_name='取消时间')),
],
options={
'db_table': 'likes',
},
),
]
| 37.290323 | 114 | 0.605536 |
48340246c107552f568488a0ba0bd90ed9aae452 | 2,483 | py | Python | flask_unchained/bundles/security/models/user.py | achiang/flask-unchained | 12788a6e618904a25ff2b571eb05ff1dc8f1840f | [
"MIT"
]
| null | null | null | flask_unchained/bundles/security/models/user.py | achiang/flask-unchained | 12788a6e618904a25ff2b571eb05ff1dc8f1840f | [
"MIT"
]
| null | null | null | flask_unchained/bundles/security/models/user.py | achiang/flask-unchained | 12788a6e618904a25ff2b571eb05ff1dc8f1840f | [
"MIT"
]
| null | null | null | from flask_unchained.bundles.sqlalchemy import db
from flask_unchained import unchained, injectable, lazy_gettext as _
from .user_role import UserRole
from ..validators import EmailValidator
MIN_PASSWORD_LENGTH = 8
class User(db.Model):
"""
Base :class:`User` model. Includes :attr:`email`, :attr:`password`, :attr:`active`,
and :attr:`confirmed_at` columns, and a many-to-many relationship to the
:class:`Role` model via the intermediary :class:`UserRole` join table.
"""
class Meta:
lazy_mapped = True
repr = ('id', 'email', 'active')
email = db.Column(db.String(64), unique=True, index=True, info=dict(
required=_('flask_unchained.bundles.security:email_required'),
validators=[EmailValidator]))
_password = db.Column('password', db.String, nullable=True)
active = db.Column(db.Boolean(name='active'), default=False)
confirmed_at = db.Column(db.DateTime(), nullable=True)
user_roles = db.relationship('UserRole', back_populates='user',
cascade='all, delete-orphan')
roles = db.association_proxy('user_roles', 'role',
creator=lambda role: UserRole(role=role))
@db.hybrid_property
def password(self):
return self._password
@password.setter
@unchained.inject('security_utils_service')
def password(self, password, security_utils_service=injectable):
self._password = security_utils_service.hash_password(password)
@classmethod
def validate_password(cls, password):
if password and len(password) < MIN_PASSWORD_LENGTH:
raise db.ValidationError(f'Password must be at least '
f'{MIN_PASSWORD_LENGTH} characters long.')
@unchained.inject('security_utils_service')
def get_auth_token(self, security_utils_service=injectable):
"""
Returns the user's authentication token.
"""
return security_utils_service.get_auth_token(self)
def has_role(self, role):
"""
Returns `True` if the user identifies with the specified role.
:param role: A role name or :class:`Role` instance
"""
if isinstance(role, str):
return role in (role.name for role in self.roles)
else:
return role in self.roles
@property
def is_authenticated(self):
return True
@property
def is_anonymous(self):
return False
| 34.486111 | 87 | 0.654048 |
d1f90735af6620889a2d262e91ca5d5ac8d2931b | 1,034 | py | Python | kubernetes/test/test_v1beta1_controller_revision.py | Prahladk09/python-1 | 2dfb3035535e4be52ba549f1ff47acbe573b73f6 | [
"Apache-2.0"
]
| 1 | 2020-04-13T09:54:21.000Z | 2020-04-13T09:54:21.000Z | kubernetes/test/test_v1beta1_controller_revision.py | Prahladk09/python-1 | 2dfb3035535e4be52ba549f1ff47acbe573b73f6 | [
"Apache-2.0"
]
| 1 | 2019-08-15T14:27:17.000Z | 2019-08-15T14:28:07.000Z | kubernetes/test/test_v1beta1_controller_revision.py | Prahladk09/python-1 | 2dfb3035535e4be52ba549f1ff47acbe573b73f6 | [
"Apache-2.0"
]
| 2 | 2020-08-05T03:06:48.000Z | 2020-08-05T16:08:21.000Z | # coding: utf-8
"""
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: v1.14.4
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from __future__ import absolute_import
import os
import sys
import unittest
import kubernetes.client
from kubernetes.client.rest import ApiException
from kubernetes.client.models.v1beta1_controller_revision import V1beta1ControllerRevision
class TestV1beta1ControllerRevision(unittest.TestCase):
""" V1beta1ControllerRevision unit test stubs """
def setUp(self):
pass
def tearDown(self):
pass
def testV1beta1ControllerRevision(self):
"""
Test V1beta1ControllerRevision
"""
# FIXME: construct object with mandatory attributes with example values
#model = kubernetes.client.models.v1beta1_controller_revision.V1beta1ControllerRevision()
pass
if __name__ == '__main__':
unittest.main()
| 22.977778 | 105 | 0.729207 |
29fd048ab56cf47db084fa79e7a28b31124b4d17 | 1,636 | py | Python | fragscapy/modlist.py | Fratso/Fragscapy | b824db6fa67a743a91c26f6239c7ee9dc86ea7fe | [
"MIT"
]
| 56 | 2019-09-19T09:09:19.000Z | 2022-02-07T01:48:48.000Z | fragscapy/modlist.py | Fratso/Fragscapy | b824db6fa67a743a91c26f6239c7ee9dc86ea7fe | [
"MIT"
]
| 5 | 2020-01-30T15:32:32.000Z | 2021-05-27T20:01:52.000Z | fragscapy/modlist.py | Fratso/Fragscapy | b824db6fa67a743a91c26f6239c7ee9dc86ea7fe | [
"MIT"
]
| 13 | 2019-09-20T16:11:58.000Z | 2021-11-23T06:33:42.000Z | """Defines a list of `Mod` objects."""
class ModList(list):
"""A list modifications.
Use the `ModList` as a classic python list, the only difference is the
`.apply(packet_list)` method available to apply the list of modifications
on a `PacketList` object.
Examples:
Assuming the all the mods and the packet list are already created:
>>> ml = ModList()
>>> ml.append(mod1)
>>> ml.append(mod2)
>>> ml.append(mod3)
>>> len(ml)
3
>>> ml.pop()
>>> ml[-1]
mod2
>>> ml.insert(1, mod4)
>>> for mod in ml:
... print(mod)
mod1
mod4
mod2
mod3
>>> ml.apply(packet_list)
"""
def __str__(self):
ret = []
ret.append("ModList [")
for mod in self:
ret.append(" - " + str(mod))
ret.append("]")
return "\n".join(ret)
def __repr__(self):
ret = []
ret.append("ModList [")
for mod in self:
ret.append(" - " + repr(mod))
ret.append("]")
return "\n".join(ret)
def apply(self, pkt_list):
"""Applies all the modifications to a packet list.
Args:
pkt_list: The `PacketList` object to modify.
Returns:
The resulting `PacketList` with all modifications applied.
"""
for mod in self:
pkt_list = mod.apply(pkt_list)
return pkt_list
def is_deterministic(self):
"""Are all the mod deterministic (i.e. non-random)."""
return all(mod.is_deterministic() for mod in self)
| 25.968254 | 77 | 0.521394 |
650209b2898ad68af7fe85802546e74cd326bf7d | 3,165 | py | Python | tests/test_classes/groups.py | dialogs/python-bot-sdk | 737152e5ef8406af0b22600ef7cefa78da9035e8 | [
"Apache-2.0"
]
| 9 | 2019-01-22T09:59:12.000Z | 2021-05-08T10:59:00.000Z | tests/test_classes/groups.py | dialogs/python-bot-sdk | 737152e5ef8406af0b22600ef7cefa78da9035e8 | [
"Apache-2.0"
]
| 29 | 2018-10-08T17:10:49.000Z | 2021-04-28T18:46:30.000Z | tests/test_classes/groups.py | dialogs/python-bot-sdk | 737152e5ef8406af0b22600ef7cefa78da9035e8 | [
"Apache-2.0"
]
| 8 | 2019-01-22T09:49:32.000Z | 2022-01-26T18:55:52.000Z | from dialog_api.groups_pb2 import RequestCreateGroup, ResponseCreateGroup, RequestLoadMembers, ResponseLoadMembers, \
RequestKickUser, RequestInviteUser, RequestEditGroupBasePermissions, RequestEditMemberPermissions, \
RequestGetGroupMemberPermissions, ResponseGetGroupMemberPermissions, RequestEditGroupTitle, \
RequestRemoveGroupAvatar, RequestEditGroupAbout, RequestLeaveGroup, RequestMakeUserAdmin, RequestTransferOwnership, \
RequestGetGroupInviteUrl, RequestGetGroupInviteUrlBase, ResponseGetGroupInviteUrlBase, RequestRevokeInviteUrl, \
RequestJoinGroup, ResponseJoinGroup, Group, RequestJoinGroupByPeer, RequestEditGroupAvatar, ResponseEditGroupAvatar
class ResponseGetGroupInviteUrl:
def __init__(self, url: str) -> None:
self.url = url
class ResponseRevokeInviteUrl:
def __init__(self, url: str) -> None:
self.url = url
class Groups:
def CreateGroup(self, request: RequestCreateGroup) -> ResponseCreateGroup:
return ResponseCreateGroup(seq=0, state=b'', group=None, user_peers=[])
def LoadMembers(self, request: RequestLoadMembers):
return ResponseLoadMembers(cursor=None, members=[])
def KickUser(self, request: RequestKickUser) -> None:
pass
def InviteUser(self, request: RequestInviteUser) -> None:
pass
def EditGroupBasePermissions(self, request: RequestEditGroupBasePermissions) -> None:
pass
def EditMemberPermissions(self, request: RequestEditMemberPermissions) -> None:
pass
def GetGroupMemberPermissions(self, request: RequestGetGroupMemberPermissions) -> ResponseGetGroupMemberPermissions:
return ResponseGetGroupMemberPermissions(permissions=[])
def EditGroupTitle(self, request: RequestEditGroupTitle) -> None:
pass
def RemoveGroupAvatar(self, request: RequestRemoveGroupAvatar) -> None:
pass
def EditGroupAbout(self, request: RequestEditGroupAbout) -> None:
pass
def LeaveGroup(self, request: RequestLeaveGroup) -> None:
pass
def MakeUserAdmin(self, request: RequestMakeUserAdmin) -> None:
pass
def TransferOwnership(self, request: RequestTransferOwnership) -> None:
pass
def GetGroupInviteUrl(self, request: RequestGetGroupInviteUrl) -> ResponseGetGroupInviteUrl:
return ResponseGetGroupInviteUrl("url")
def GetGroupInviteUrlBase(self, request: RequestGetGroupInviteUrlBase) -> ResponseGetGroupInviteUrlBase:
return ResponseGetGroupInviteUrlBase(url='url')
def RevokeInviteUrl(self, request: RequestRevokeInviteUrl) -> ResponseRevokeInviteUrl:
return ResponseRevokeInviteUrl("url")
def JoinGroup(self, request: RequestJoinGroup) -> ResponseJoinGroup:
return ResponseJoinGroup(group=Group(id=0, access_hash=0, data=None),
user_peers=[], mid=None, seq=0, state=b'', date=0)
def JoinGroupByPeer(self, request: RequestJoinGroupByPeer) -> None:
pass
def EditGroupAvatar(self, request: RequestEditGroupAvatar) -> ResponseEditGroupAvatar:
return ResponseEditGroupAvatar(avatar=None, seq=0, state=b'', date=0, mid=None)
| 41.103896 | 121 | 0.747551 |
a9dc797815d0be1cbd84f8ef4f62959ca932aea9 | 11,365 | py | Python | pyNNsMD/models/mlp_eg.py | aimat-lab/NNsForMD | e52c19f39c2039580b9ab4e5b7f78a35a3300bac | [
"MIT"
]
| 2 | 2021-08-03T09:45:09.000Z | 2022-03-04T08:39:05.000Z | pyNNsMD/models/mlp_eg.py | aimat-lab/NNsForMD | e52c19f39c2039580b9ab4e5b7f78a35a3300bac | [
"MIT"
]
| null | null | null | pyNNsMD/models/mlp_eg.py | aimat-lab/NNsForMD | e52c19f39c2039580b9ab4e5b7f78a35a3300bac | [
"MIT"
]
| 1 | 2021-07-21T01:22:50.000Z | 2021-07-21T01:22:50.000Z | """
Tensorflow keras model definitions for energy and gradient.
There are two definitions: the subclassed EnergyGradientModel and a precomputed model to
multiply with the feature derivative for training, which overwrites training/predict step.
"""
import numpy as np
import tensorflow as tf
import tensorflow.keras as ks
from pyNNsMD.layers.features import FeatureGeometric
from pyNNsMD.layers.gradients import EmptyGradient
from pyNNsMD.layers.mlp import MLP
from pyNNsMD.layers.normalize import ConstLayerNormalization
from pyNNsMD.scaler.general import SegmentStandardScaler
class EnergyGradientModel(ks.Model):
"""
Subclassed tf.keras.model for energy/gradient which outputs both energy and gradient from coordinates.
This is not used for fitting, only for prediction as for fitting a feature-precomputed model is used instead.
The model is supposed to be saved and exported for MD code.
"""
def __init__(self,
states=1,
atoms=2,
invd_index=None,
angle_index=None,
dihed_index=None,
nn_size=100,
depth=3,
activ='selu',
use_reg_activ=None,
use_reg_weight=None,
use_reg_bias=None,
use_dropout=False,
dropout=0.01,
normalization_mode=1,
energy_only = False,
precomputed_features = False,
output_as_dict = False,
**kwargs):
"""
Initialize Layer
Args:
states:
atoms:
invd_index:
angle_index:
dihed_index:
nn_size:
depth:
activ:
use_reg_activ:
use_reg_weight:
use_reg_bias:
use_dropout:
dropout:
**kwargs:
"""
super(EnergyGradientModel, self).__init__(**kwargs)
self.in_invd_index = invd_index
self.in_angle_index = angle_index
self.in_dihed_index = dihed_index
self.nn_size = nn_size
self.depth = depth
self.activ = activ
self.use_reg_activ = use_reg_activ
self.use_reg_weight = use_reg_weight
self.use_reg_bias = use_reg_bias
self.use_dropout = use_dropout
self.dropout = dropout
# Control the properties
self.energy_only = energy_only
self.output_as_dict = output_as_dict
self.eg_atoms = int(atoms)
self.eg_states = int(states)
self.normalization_mode = normalization_mode
out_dim = int(states)
indim = int(atoms)
# Allow for all distances, backward compatible
if isinstance(invd_index, bool):
if invd_index:
invd_index = [[i, j] for i in range(0, int(atoms)) for j in range(0, i)]
use_invd_index = len(invd_index) > 0 if isinstance(invd_index, list) or isinstance(invd_index,
np.ndarray) else False
use_angle_index = len(angle_index) > 0 if isinstance(angle_index, list) or isinstance(angle_index,
np.ndarray) else False
use_dihed_index = len(dihed_index) > 0 if isinstance(dihed_index, list) or isinstance(dihed_index,
np.ndarray) else False
invd_index = np.array(invd_index, dtype=np.int64) if use_invd_index else None
angle_index = np.array(angle_index, dtype=np.int64) if use_angle_index else None
dihed_index = np.array(dihed_index, dtype=np.int64) if use_dihed_index else None
invd_shape = invd_index.shape if use_invd_index else None
angle_shape = angle_index.shape if use_angle_index else None
dihed_shape = dihed_index.shape if use_dihed_index else None
self.feat_layer = FeatureGeometric(invd_shape=invd_shape,
angle_shape=angle_shape,
dihed_shape=dihed_shape,
name="feat_geo"
)
self.feat_layer.set_mol_index(invd_index, angle_index, dihed_index)
self.std_layer = ConstLayerNormalization(axis=-1, name='feat_std')
self.mlp_layer = MLP(nn_size,
dense_depth=depth,
dense_bias=True,
dense_bias_last=True,
dense_activ=activ,
dense_activ_last=activ,
dense_activity_regularizer=use_reg_activ,
dense_kernel_regularizer=use_reg_weight,
dense_bias_regularizer=use_reg_bias,
dropout_use=use_dropout,
dropout_dropout=dropout,
name='mlp'
)
self.energy_layer = ks.layers.Dense(out_dim, name='energy', use_bias=True, activation='linear')
self.force = EmptyGradient(mult_states=out_dim, atoms=indim,
name='force') # Will be differentiated in fit/predict/evaluate
# Need to build model already to set std layer
self.precomputed_features = False
self.build((None, indim, 3))
self.precomputed_features = precomputed_features
def call(self, data, training=False, **kwargs):
"""
Call the model output, forward pass.
Args:
data (tf.tensor): Coordinates.
training (bool, optional): Training Mode. Defaults to False.
Returns:
y_pred (list): List of tf.tensor for predicted [energy,gradient]
"""
# Unpack the data
x = data
y_pred = None
if self.energy_only and not self.precomputed_features:
feat_flat = self.feat_layer(x)
feat_flat_std = self.std_layer(feat_flat)
temp_hidden = self.mlp_layer(feat_flat_std, training=training)
temp_e = self.energy_layer(temp_hidden)
temp_g = self.force(x)
y_pred = [temp_e, temp_g]
elif not self.energy_only and not self.precomputed_features:
with tf.GradientTape() as tape2:
tape2.watch(x)
feat_flat = self.feat_layer(x)
feat_flat_std = self.std_layer(feat_flat)
temp_hidden = self.mlp_layer(feat_flat_std, training=training)
temp_e = self.energy_layer(temp_hidden)
temp_g = tape2.batch_jacobian(temp_e, x)
_ = self.force(x)
y_pred = [temp_e, temp_g]
elif self.precomputed_features and not self.energy_only:
x1 = x[0]
x2 = x[1]
with tf.GradientTape() as tape2:
tape2.watch(x1)
feat_flat_std = self.std_layer(x1)
temp_hidden = self.mlp_layer(feat_flat_std, training=training)
atpot = self.energy_layer(temp_hidden)
grad = tape2.batch_jacobian(atpot, x1)
grad = ks.backend.batch_dot(grad, x2, axes=(2, 1))
y_pred = [atpot, grad]
elif self.precomputed_features and self.energy_only:
x1 = x[0]
# x2 = x[1]
feat_flat_std = self.std_layer(x1)
temp_hidden = self.mlp_layer(feat_flat_std, training=training)
temp_e = self.energy_layer(temp_hidden)
temp_g = self.force(x1)
y_pred = [temp_e, temp_g]
if self.output_as_dict:
out = {'energy': y_pred[0], 'force': y_pred[1]}
else:
out = y_pred
return out
@tf.function
def predict_chunk_feature(self, tf_x):
with tf.GradientTape() as tape2:
tape2.watch(tf_x)
feat_pred = self.feat_layer(tf_x, training=False) # Forward pass
grad = tape2.batch_jacobian(feat_pred, tf_x)
return feat_pred, grad
def precompute_feature_in_chunks(self, x, batch_size):
np_x = []
np_grad = []
for j in range(int(np.ceil(len(x) / batch_size))):
a = int(batch_size * j)
b = int(batch_size * j + batch_size)
tf_x = tf.convert_to_tensor(x[a:b], dtype=tf.float32)
feat_pred, grad = self.predict_chunk_feature(tf_x)
np_x.append(np.array(feat_pred.numpy()))
np_grad.append(np.array(grad.numpy()))
np_x = np.concatenate(np_x, axis=0)
np_grad = np.concatenate(np_grad, axis=0)
return np_x, np_grad
def set_const_normalization_from_features(self, feat_x, normalization_mode=None):
if normalization_mode is None:
normalization_mode = self.normalization_mode
else:
self.normalization_mode = normalization_mode
feat_x_mean, feat_x_std = self.get_layer('feat_std').get_weights()
if normalization_mode == 1:
feat_x_mean = np.mean(feat_x, axis=0, keepdims=True)
feat_x_std = np.std(feat_x, axis=0, keepdims=True)
elif normalization_mode == 2:
seg_scaler = SegmentStandardScaler(self.get_layer('feat_geo').get_feature_type_segmentation())
seg_scaler.fit(y=feat_x)
feat_x_mean, feat_x_std = np.array(seg_scaler.get_params()["feat_mean"]), np.array(
seg_scaler.get_params()["feat_std"])
self.get_layer('feat_std').set_weights([feat_x_mean, feat_x_std])
return [feat_x_mean, feat_x_std]
def fit(self, **kwargs):
if self.precomputed_features:
self.set_const_normalization_from_features(kwargs['x'][0])
return super(EnergyGradientModel, self).fit(**kwargs)
def get_config(self):
# conf = super(EnergyGradientModel, self).get_config()
conf = {}
conf.update({
'atoms': self.eg_atoms,
'states': self.eg_states,
'invd_index': self.in_invd_index,
'angle_index': self.in_angle_index,
'dihed_index': self.in_dihed_index,
'nn_size': self.nn_size,
'depth': self.depth,
'activ': self.activ,
'use_reg_activ': self.use_reg_activ,
'use_reg_weight': self.use_reg_weight,
'use_reg_bias': self.use_reg_bias,
'use_dropout': self.use_dropout,
'dropout': self.dropout,
'normalization_mode': self.normalization_mode,
'energy_only': self.energy_only,
'precomputed_features': self.precomputed_features,
'output_as_dict': self.output_as_dict
})
return conf
def save(self,filepath,**kwargs):
# copy to new model
self_conf = self.get_config()
self_conf['precomputed_features'] = False
copy_model = EnergyGradientModel(**self_conf)
copy_model.set_weights(self.get_weights())
# Make graph and test with training data
copy_model.predict(np.ones((1,self.eg_atoms,3)))
tf.keras.models.save_model(copy_model,filepath,**kwargs) | 40.589286 | 116 | 0.580994 |
f805f742c5aab1dd1aee6ac09777cd63a2f29af9 | 476 | py | Python | 2 - Continuous Control -DDPG/continuous_control_ddpg_reacher20.py | lalopey/drl | 4cc28158be70d06113dc680644c0b3d3241b7b51 | [
"MIT"
]
| null | null | null | 2 - Continuous Control -DDPG/continuous_control_ddpg_reacher20.py | lalopey/drl | 4cc28158be70d06113dc680644c0b3d3241b7b51 | [
"MIT"
]
| null | null | null | 2 - Continuous Control -DDPG/continuous_control_ddpg_reacher20.py | lalopey/drl | 4cc28158be70d06113dc680644c0b3d3241b7b51 | [
"MIT"
]
| null | null | null | from drltools.utils import trainer, ddpgmulti_config
from drltools.agent.agent import DDPGMultiAgent
from unityagents import UnityEnvironment
env = UnityEnvironment(file_name="unity_environments/Reacher20_mac.app", worker_id=1)
config = ddpgmulti_config
agent_class = DDPGMultiAgent
n_episodes = 2000
max_t = 1000
solved_score = 30
title = 'DDPG Reacher 20 agents'
if __name__ == "__main__":
trainer(env, config, agent_class, n_episodes, max_t, solved_score, title)
| 25.052632 | 85 | 0.802521 |
b2521dbb21208019f472923eee6f6c27f6653193 | 2,017 | py | Python | lib/notification_service/notification_service/cli/commands/db_command.py | SteNicholas/ai-flow | 2c70547981f1516f0e37bbe6936a1b7cccd31822 | [
"Apache-2.0"
]
| null | null | null | lib/notification_service/notification_service/cli/commands/db_command.py | SteNicholas/ai-flow | 2c70547981f1516f0e37bbe6936a1b7cccd31822 | [
"Apache-2.0"
]
| null | null | null | lib/notification_service/notification_service/cli/commands/db_command.py | SteNicholas/ai-flow | 2c70547981f1516f0e37bbe6936a1b7cccd31822 | [
"Apache-2.0"
]
| null | null | null | # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
"""DB command"""
import logging
from notification_service.settings import get_configuration
from notification_service.util import db
_logger = logging.getLogger(__name__)
def init(args):
"""Init the metadata database"""
config = get_configuration()
_logger.info('Initialize the database, db uri: {}'.format(config.db_uri))
db.upgrade(url=config.db_uri)
def reset(args):
"""Reset the metadata database"""
config = get_configuration()
_logger.info('Reset the database, db uri: {}'.format(config.db_uri))
if args.yes or input("This will drop existing tables if they exist. Proceed? (y/n)").upper() == "Y":
db.reset_db(url=config.db_uri)
else:
_logger.info('Cancel reset the database, db uri: {}'.format(config.db_uri))
def upgrade(args):
"""Upgrade the metadata database"""
config = get_configuration()
_logger.info('Upgrade the database, db uri: {}'.format(config.db_uri))
db.upgrade(url=config.db_uri, version=args.version)
def downgrade(args):
"""Downgrade the metadata database"""
config = get_configuration()
_logger.info('Downgrade the database, db uri: {}'.format(config.db_uri))
db.downgrade(url=config.db_uri, version=args.version)
| 36.672727 | 104 | 0.729301 |
2589125ec5e5791900ed3487f08d45753a916bf6 | 1,794 | py | Python | spgg_dialog.py | euriconicacio/SPGG-Plugin | 84f350bd1343add2c634e9bb07c7d27c8be66f42 | [
"MIT"
]
| null | null | null | spgg_dialog.py | euriconicacio/SPGG-Plugin | 84f350bd1343add2c634e9bb07c7d27c8be66f42 | [
"MIT"
]
| null | null | null | spgg_dialog.py | euriconicacio/SPGG-Plugin | 84f350bd1343add2c634e9bb07c7d27c8be66f42 | [
"MIT"
]
| null | null | null | # -*- coding: utf-8 -*-
"""
/***************************************************************************
SPGGDialog
A QGIS plugin
Single-Point GEM Generator
-------------------
begin : 2016-10-03
git sha : $Format:%H$
copyright : (C) 2016 by Eurico Nicacio - EB/UFPR
email : [email protected]
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
"""
import os
from PyQt4 import QtGui, uic
FORM_CLASS, _ = uic.loadUiType(os.path.join(
os.path.dirname(__file__), 'spgg_dialog_base.ui'))
class SPGGDialog(QtGui.QDialog, FORM_CLASS):
def __init__(self, parent=None):
"""Constructor."""
super(SPGGDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
| 41.72093 | 77 | 0.424192 |
8f5587a5a567d41f88b86e95608b449b9b14997d | 551 | py | Python | update_supply_chain_information/supply_chains/migrations/0018_alter_supplychain_vulnerability_status.py | uktrade/update-supply-chain-information | 5cdcc795257b8351cf11b57487b194012ee8886d | [
"MIT"
]
| null | null | null | update_supply_chain_information/supply_chains/migrations/0018_alter_supplychain_vulnerability_status.py | uktrade/update-supply-chain-information | 5cdcc795257b8351cf11b57487b194012ee8886d | [
"MIT"
]
| 204 | 2021-05-26T16:15:04.000Z | 2022-02-14T05:10:44.000Z | update_supply_chain_information/supply_chains/migrations/0018_alter_supplychain_vulnerability_status.py | uktrade/defend-data-capture | 5cdcc795257b8351cf11b57487b194012ee8886d | [
"MIT"
]
| 1 | 2021-06-26T10:28:30.000Z | 2021-06-26T10:28:30.000Z | # Generated by Django 3.2.2 on 2021-06-16 10:12
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("supply_chains", "0017_alter_strategicaction_supporting_organisations"),
]
operations = [
migrations.AlterField(
model_name="supplychain",
name="vulnerability_status",
field=models.CharField(
choices=[("RED", "Red"), ("AMBER", "Amber"), ("GREEN", "Green")],
max_length=6,
),
),
]
| 25.045455 | 81 | 0.573503 |
195c636230da06644dca8e5d7daaa3a470fbbe83 | 1,641 | py | Python | move.py | Conundrum4/Group-robotics-project | 8df5bdc03bf1a2c065e59a3ba7ff2edbc77751a9 | [
"MIT"
]
| null | null | null | move.py | Conundrum4/Group-robotics-project | 8df5bdc03bf1a2c065e59a3ba7ff2edbc77751a9 | [
"MIT"
]
| null | null | null | move.py | Conundrum4/Group-robotics-project | 8df5bdc03bf1a2c065e59a3ba7ff2edbc77751a9 | [
"MIT"
]
| null | null | null | #!/usr/bin/env python
import math
from math import sin, cos, pi
import rospy
import tf
from nav_msgs.msg import Odometry
from geometry_msgs.msg import Point, Pose, Quaternion, Twist, Vector3
rospy.init_node('odometry_publisher')
odom_pub = rospy.Publisher("odom", Odometry, queue_size=50)
odom_broadcaster = tf.TransformBroadcaster()
x = 0.0
y = 0.0
th = 0.0
vx = 0.1
vy = -0.1
vth = 0.1
current_time = rospy.Time.now()
last_time = rospy.Time.now()
r = rospy.Rate(1.0)
while not rospy.is_shutdown():
current_time = rospy.Time.now()
# compute odometry in a typical way given the velocities of the robot
dt = (current_time - last_time).to_sec()
delta_x = (vx * cos(th) - vy * sin(th)) * dt
delta_y = (vx * sin(th) + vy * cos(th)) * dt
delta_th = vth * dt
x += delta_x
y += delta_y
th += delta_th
# since all odometry is 6DOF we'll need a quaternion created from yaw
odom_quat = tf.transformations.quaternion_from_euler(0, 0, th)
# first, we'll publish the transform over tf
odom_broadcaster.sendTransform(
(x, y, 0.),
odom_quat,
current_time,
"base_link",
"odom"
)
# next, we'll publish the odometry message over ROS
odom = Odometry()
odom.header.stamp = current_time
odom.header.frame_id = "odom"
# set the position
odom.pose.pose = Pose(Point(x, y, 0.), Quaternion(*odom_quat))
# set the velocity
odom.child_frame_id = "base_link"
odom.twist.twist = Twist(Vector3(vx, vy, 0), Vector3(0, 0, vth))
# publish the message
odom_pub.publish(odom)
last_time = current_time
r.sleep()
| 23.442857 | 73 | 0.656307 |
c4e1e6239d9ed489cbf9d5bca310929b63843ac9 | 67,692 | py | Python | IntelFsp2Pkg/Tools/GenCfgOpt.py | mjg59/edk2 | 6a34c1ce705470124d35d6ce6ee85e3f098f8fd5 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
]
| 1 | 2019-09-28T22:17:53.000Z | 2019-09-28T22:17:53.000Z | IntelFsp2Pkg/Tools/GenCfgOpt.py | mjg59/edk2 | 6a34c1ce705470124d35d6ce6ee85e3f098f8fd5 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
]
| null | null | null | IntelFsp2Pkg/Tools/GenCfgOpt.py | mjg59/edk2 | 6a34c1ce705470124d35d6ce6ee85e3f098f8fd5 | [
"Python-2.0",
"Zlib",
"BSD-2-Clause",
"MIT",
"BSD-2-Clause-Patent",
"BSD-3-Clause"
]
| null | null | null | ## @ GenCfgOpt.py
#
# Copyright (c) 2014 - 2019, Intel Corporation. All rights reserved.<BR>
# SPDX-License-Identifier: BSD-2-Clause-Patent
#
##
import os
import re
import sys
import struct
from datetime import date
from functools import reduce
# Generated file copyright header
__copyright_txt__ = """## @file
#
# THIS IS AUTO-GENERATED FILE BY BUILD TOOLS AND PLEASE DO NOT MAKE MODIFICATION.
#
# This file lists all VPD informations for a platform collected by build.exe.
#
# Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
# This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
#
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#
"""
__copyright_bsf__ = """/** @file
Boot Setting File for Platform Configuration.
Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
This file is automatically generated. Please do NOT modify !!!
**/
"""
__copyright_h__ = """/** @file
Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.
This file is automatically generated. Please do NOT modify !!!
**/
"""
BuildOptionPcd = []
class CLogicalExpression:
def __init__(self):
self.index = 0
self.string = ''
def errExit(self, err = ''):
print ("ERROR: Express parsing for:")
print (" %s" % self.string)
print (" %s^" % (' ' * self.index))
if err:
print ("INFO : %s" % err)
raise SystemExit
def getNonNumber (self, n1, n2):
if not n1.isdigit():
return n1
if not n2.isdigit():
return n2
return None
def getCurr(self, lens = 1):
try:
if lens == -1:
return self.string[self.index :]
else:
if self.index + lens > len(self.string):
lens = len(self.string) - self.index
return self.string[self.index : self.index + lens]
except Exception:
return ''
def isLast(self):
return self.index == len(self.string)
def moveNext(self, len = 1):
self.index += len
def skipSpace(self):
while not self.isLast():
if self.getCurr() in ' \t':
self.moveNext()
else:
return
def normNumber (self, val):
return True if val else False
def getNumber(self, var):
var = var.strip()
if re.match('^0x[a-fA-F0-9]+$', var):
value = int(var, 16)
elif re.match('^[+-]?\d+$', var):
value = int(var, 10)
else:
value = None
return value
def parseValue(self):
self.skipSpace()
var = ''
while not self.isLast():
char = self.getCurr()
if re.match('^[\w.]', char):
var += char
self.moveNext()
else:
break
val = self.getNumber(var)
if val is None:
value = var
else:
value = "%d" % val
return value
def parseSingleOp(self):
self.skipSpace()
if re.match('^NOT\W', self.getCurr(-1)):
self.moveNext(3)
op = self.parseBrace()
val = self.getNumber (op)
if val is None:
self.errExit ("'%s' is not a number" % op)
return "%d" % (not self.normNumber(int(op)))
else:
return self.parseValue()
def parseBrace(self):
self.skipSpace()
char = self.getCurr()
if char == '(':
self.moveNext()
value = self.parseExpr()
self.skipSpace()
if self.getCurr() != ')':
self.errExit ("Expecting closing brace or operator")
self.moveNext()
return value
else:
value = self.parseSingleOp()
return value
def parseCompare(self):
value = self.parseBrace()
while True:
self.skipSpace()
char = self.getCurr()
if char in ['<', '>']:
self.moveNext()
next = self.getCurr()
if next == '=':
op = char + next
self.moveNext()
else:
op = char
result = self.parseBrace()
test = self.getNonNumber(result, value)
if test is None:
value = "%d" % self.normNumber(eval (value + op + result))
else:
self.errExit ("'%s' is not a valid number for comparision" % test)
elif char in ['=', '!']:
op = self.getCurr(2)
if op in ['==', '!=']:
self.moveNext(2)
result = self.parseBrace()
test = self.getNonNumber(result, value)
if test is None:
value = "%d" % self.normNumber((eval (value + op + result)))
else:
value = "%d" % self.normNumber(eval ("'" + value + "'" + op + "'" + result + "'"))
else:
break
else:
break
return value
def parseAnd(self):
value = self.parseCompare()
while True:
self.skipSpace()
if re.match('^AND\W', self.getCurr(-1)):
self.moveNext(3)
result = self.parseCompare()
test = self.getNonNumber(result, value)
if test is None:
value = "%d" % self.normNumber(int(value) & int(result))
else:
self.errExit ("'%s' is not a valid op number for AND" % test)
else:
break
return value
def parseOrXor(self):
value = self.parseAnd()
op = None
while True:
self.skipSpace()
op = None
if re.match('^XOR\W', self.getCurr(-1)):
self.moveNext(3)
op = '^'
elif re.match('^OR\W', self.getCurr(-1)):
self.moveNext(2)
op = '|'
else:
break
if op:
result = self.parseAnd()
test = self.getNonNumber(result, value)
if test is None:
value = "%d" % self.normNumber(eval (value + op + result))
else:
self.errExit ("'%s' is not a valid op number for XOR/OR" % test)
return value
def parseExpr(self):
return self.parseOrXor()
def getResult(self):
value = self.parseExpr()
self.skipSpace()
if not self.isLast():
self.errExit ("Unexpected character found '%s'" % self.getCurr())
test = self.getNumber(value)
if test is None:
self.errExit ("Result '%s' is not a number" % value)
return int(value)
def evaluateExpress (self, Expr):
self.index = 0
self.string = Expr
if self.getResult():
Result = True
else:
Result = False
return Result
class CGenCfgOpt:
def __init__(self):
self.Debug = False
self.Error = ''
self._GlobalDataDef = """
GlobalDataDef
SKUID = 0, "DEFAULT"
EndGlobalData
"""
self._BuidinOptionTxt = """
List &EN_DIS
Selection 0x1 , "Enabled"
Selection 0x0 , "Disabled"
EndList
"""
self._BsfKeyList = ['FIND','NAME','HELP','TYPE','PAGE','OPTION','ORDER']
self._HdrKeyList = ['HEADER','STRUCT', 'EMBED', 'COMMENT']
self._BuidinOption = {'$EN_DIS' : 'EN_DIS'}
self._MacroDict = {}
self._PcdsDict = {}
self._CfgBlkDict = {}
self._CfgPageDict = {}
self._CfgItemList = []
self._DscFile = ''
self._FvDir = ''
self._MapVer = 0
def ParseMacros (self, MacroDefStr):
# ['-DABC=1', '-D', 'CFG_DEBUG=1', '-D', 'CFG_OUTDIR=Build']
self._MacroDict = {}
IsExpression = False
for Macro in MacroDefStr:
if Macro.startswith('-D'):
IsExpression = True
if len(Macro) > 2:
Macro = Macro[2:]
else :
continue
if IsExpression:
IsExpression = False
Match = re.match("(\w+)=(.+)", Macro)
if Match:
self._MacroDict[Match.group(1)] = Match.group(2)
else:
Match = re.match("(\w+)", Macro)
if Match:
self._MacroDict[Match.group(1)] = ''
if len(self._MacroDict) == 0:
Error = 1
else:
Error = 0
if self.Debug:
print ("INFO : Macro dictionary:")
for Each in self._MacroDict:
print (" $(%s) = [ %s ]" % (Each , self._MacroDict[Each]))
return Error
def EvaulateIfdef (self, Macro):
Result = Macro in self._MacroDict
if self.Debug:
print ("INFO : Eval Ifdef [%s] : %s" % (Macro, Result))
return Result
def ExpandMacros (self, Input):
Line = Input
Match = re.findall("\$\(\w+\)", Input)
if Match:
for Each in Match:
Variable = Each[2:-1]
if Variable in self._MacroDict:
Line = Line.replace(Each, self._MacroDict[Variable])
else:
if self.Debug:
print ("WARN : %s is not defined" % Each)
Line = Line.replace(Each, Each[2:-1])
return Line
def ExpandPcds (self, Input):
Line = Input
Match = re.findall("(\w+\.\w+)", Input)
if Match:
for PcdName in Match:
if PcdName in self._PcdsDict:
Line = Line.replace(PcdName, self._PcdsDict[PcdName])
else:
if self.Debug:
print ("WARN : %s is not defined" % PcdName)
return Line
def EvaluateExpress (self, Expr):
ExpExpr = self.ExpandPcds(Expr)
ExpExpr = self.ExpandMacros(ExpExpr)
LogExpr = CLogicalExpression()
Result = LogExpr.evaluateExpress (ExpExpr)
if self.Debug:
print ("INFO : Eval Express [%s] : %s" % (Expr, Result))
return Result
def FormatListValue(self, ConfigDict):
Struct = ConfigDict['struct']
if Struct not in ['UINT8','UINT16','UINT32','UINT64']:
return
dataarray = []
binlist = ConfigDict['value'][1:-1].split(',')
for each in binlist:
each = each.strip()
if each.startswith('0x'):
value = int(each, 16)
else:
value = int(each)
dataarray.append(value)
unit = int(Struct[4:]) / 8
if int(ConfigDict['length']) != unit * len(dataarray):
raise Exception("Array size is not proper for '%s' !" % ConfigDict['cname'])
bytearray = []
for each in dataarray:
value = each
for loop in range(int(unit)):
bytearray.append("0x%02X" % (value & 0xFF))
value = value >> 8
newvalue = '{' + ','.join(bytearray) + '}'
ConfigDict['value'] = newvalue
return ""
def ParseDscFile (self, DscFile, FvDir):
Hardcode = False
AutoAlign = False
self._CfgItemList = []
self._CfgPageDict = {}
self._CfgBlkDict = {}
self._DscFile = DscFile
self._FvDir = FvDir
IsDefSect = False
IsPcdSect = False
IsUpdSect = False
IsVpdSect = False
IfStack = []
ElifStack = []
Error = 0
ConfigDict = {}
DscFd = open(DscFile, "r")
DscLines = DscFd.readlines()
DscFd.close()
MaxAlign = 32 #Default align to 32, but if there are 64 bit unit, align to 64
SizeAlign = 0 #record the struct max align
while len(DscLines):
DscLine = DscLines.pop(0).strip()
Handle = False
Match = re.match("^\[(.+)\]", DscLine)
if Match is not None:
IsDefSect = False
IsPcdSect = False
IsVpdSect = False
IsUpdSect = False
if Match.group(1).lower() == "Defines".lower():
IsDefSect = True
if (Match.group(1).lower() == "PcdsFeatureFlag".lower() or Match.group(1).lower() == "PcdsFixedAtBuild".lower()):
IsPcdSect = True
elif Match.group(1).lower() == "PcdsDynamicVpd.Upd".lower():
ConfigDict = {}
ConfigDict['header'] = 'ON'
ConfigDict['region'] = 'UPD'
ConfigDict['order'] = -1
ConfigDict['page'] = ''
ConfigDict['name'] = ''
ConfigDict['find'] = ''
ConfigDict['struct'] = ''
ConfigDict['embed'] = ''
ConfigDict['comment'] = ''
ConfigDict['subreg'] = []
IsUpdSect = True
Offset = 0
else:
if IsDefSect or IsPcdSect or IsUpdSect or IsVpdSect:
if re.match("^!else($|\s+#.+)", DscLine):
if IfStack:
IfStack[-1] = not IfStack[-1]
else:
print("ERROR: No paired '!if' found for '!else' for line '%s'" % DscLine)
raise SystemExit
elif re.match("^!endif($|\s+#.+)", DscLine):
if IfStack:
IfStack.pop()
Level = ElifStack.pop()
if Level > 0:
del IfStack[-Level:]
else:
print("ERROR: No paired '!if' found for '!endif' for line '%s'" % DscLine)
raise SystemExit
else:
Result = False
Match = re.match("!(ifdef|ifndef)\s+(.+)", DscLine)
if Match:
Result = self.EvaulateIfdef (Match.group(2))
if Match.group(1) == 'ifndef':
Result = not Result
IfStack.append(Result)
ElifStack.append(0)
else:
Match = re.match("!(if|elseif)\s+(.+)", DscLine.split("#")[0])
if Match:
Result = self.EvaluateExpress(Match.group(2))
if Match.group(1) == "if":
ElifStack.append(0)
IfStack.append(Result)
else: #elseif
if IfStack:
IfStack[-1] = not IfStack[-1]
IfStack.append(Result)
ElifStack[-1] = ElifStack[-1] + 1
else:
print("ERROR: No paired '!if' found for '!elif' for line '%s'" % DscLine)
raise SystemExit
else:
if IfStack:
Handle = reduce(lambda x,y: x and y, IfStack)
else:
Handle = True
if Handle:
Match = re.match("!include\s+(.+)", DscLine)
if Match:
IncludeFilePath = Match.group(1)
IncludeFilePath = self.ExpandMacros(IncludeFilePath)
PackagesPath = os.getenv("PACKAGES_PATH")
if PackagesPath:
for PackagePath in PackagesPath.split(os.pathsep):
IncludeFilePathAbs = os.path.join(os.path.normpath(PackagePath), os.path.normpath(IncludeFilePath))
if os.path.exists(IncludeFilePathAbs):
IncludeDsc = open(IncludeFilePathAbs, "r")
break
else:
IncludeDsc = open(IncludeFilePath, "r")
if IncludeDsc == None:
print("ERROR: Cannot open file '%s'" % IncludeFilePath)
raise SystemExit
NewDscLines = IncludeDsc.readlines()
IncludeDsc.close()
DscLines = NewDscLines + DscLines
Offset = 0
else:
if DscLine.startswith('!'):
print("ERROR: Unrecoginized directive for line '%s'" % DscLine)
raise SystemExit
if not Handle:
continue
if IsDefSect:
#DEFINE UPD_TOOL_GUID = 8C3D856A-9BE6-468E-850A-24F7A8D38E09
#DEFINE FSP_T_UPD_TOOL_GUID = 34686CA3-34F9-4901-B82A-BA630F0714C6
#DEFINE FSP_M_UPD_TOOL_GUID = 39A250DB-E465-4DD1-A2AC-E2BD3C0E2385
#DEFINE FSP_S_UPD_TOOL_GUID = CAE3605B-5B34-4C85-B3D7-27D54273C40F
Match = re.match("^\s*(?:DEFINE\s+)*(\w+)\s*=\s*([-.\w]+)", DscLine)
if Match:
self._MacroDict[Match.group(1)] = Match.group(2)
if self.Debug:
print ("INFO : DEFINE %s = [ %s ]" % (Match.group(1), Match.group(2)))
elif IsPcdSect:
#gSiPkgTokenSpaceGuid.PcdTxtEnable|FALSE
#gSiPkgTokenSpaceGuid.PcdOverclockEnable|TRUE
Match = re.match("^\s*([\w\.]+)\s*\|\s*(\w+)", DscLine)
if Match:
self._PcdsDict[Match.group(1)] = Match.group(2)
if self.Debug:
print ("INFO : PCD %s = [ %s ]" % (Match.group(1), Match.group(2)))
i = 0
while i < len(BuildOptionPcd):
Match = re.match("\s*([\w\.]+)\s*\=\s*(\w+)", BuildOptionPcd[i])
if Match:
self._PcdsDict[Match.group(1)] = Match.group(2)
i += 1
else:
Match = re.match("^\s*#\s+(!BSF|@Bsf|!HDR)\s+(.+)", DscLine)
if Match:
Remaining = Match.group(2)
if Match.group(1) == '!BSF' or Match.group(1) == '@Bsf':
Match = re.match("(?:^|.+\s+)PAGES:{(.+?)}", Remaining)
if Match:
# !BSF PAGES:{HSW:"Haswell System Agent", LPT:"Lynx Point PCH"}
PageList = Match.group(1).split(',')
for Page in PageList:
Page = Page.strip()
Match = re.match("(\w+):\"(.+)\"", Page)
self._CfgPageDict[Match.group(1)] = Match.group(2)
Match = re.match("(?:^|.+\s+)BLOCK:{NAME:\"(.+)\"\s*,\s*VER:\"(.+)\"\s*}", Remaining)
if Match:
self._CfgBlkDict['name'] = Match.group(1)
self._CfgBlkDict['ver'] = Match.group(2)
for Key in self._BsfKeyList:
Match = re.match("(?:^|.+\s+)%s:{(.+?)}" % Key, Remaining)
if Match:
if Key in ['NAME', 'HELP', 'OPTION'] and Match.group(1).startswith('+'):
ConfigDict[Key.lower()] += Match.group(1)[1:]
else:
ConfigDict[Key.lower()] = Match.group(1)
else:
for Key in self._HdrKeyList:
Match = re.match("(?:^|.+\s+)%s:{(.+?)}" % Key, Remaining)
if Match:
ConfigDict[Key.lower()] = Match.group(1)
Match = re.match("^\s*#\s+@Prompt\s+(.+)", DscLine)
if Match:
ConfigDict['name'] = Match.group(1)
Match = re.match("^\s*#\s*@ValidList\s*(.+)\s*\|\s*(.+)\s*\|\s*(.+)\s*", DscLine)
if Match:
if Match.group(2).strip() in self._BuidinOption:
ConfigDict['option'] = Match.group(2).strip()
else:
OptionValueList = Match.group(2).split(',')
OptionStringList = Match.group(3).split(',')
Index = 0
for Option in OptionValueList:
Option = Option.strip()
ConfigDict['option'] = ConfigDict['option'] + str(Option) + ':' + OptionStringList[Index].strip()
Index += 1
if Index in range(len(OptionValueList)):
ConfigDict['option'] += ', '
ConfigDict['type'] = "Combo"
Match = re.match("^\s*#\s*@ValidRange\s*(.+)\s*\|\s*(.+)\s*-\s*(.+)\s*", DscLine)
if Match:
if "0x" in Match.group(2) or "0x" in Match.group(3):
ConfigDict['type'] = "EditNum, HEX, (%s,%s)" % (Match.group(2), Match.group(3))
else:
ConfigDict['type'] = "EditNum, DEC, (%s,%s)" % (Match.group(2), Match.group(3))
Match = re.match("^\s*##\s+(.+)", DscLine)
if Match:
ConfigDict['help'] = Match.group(1)
# Check VPD/UPD
if IsUpdSect:
Match = re.match("^([_a-zA-Z0-9]+).([_a-zA-Z0-9]+)\s*\|\s*(0x[0-9A-F]+|\*)\s*\|\s*(\d+|0x[0-9a-fA-F]+)\s*\|\s*(.+)",DscLine)
else:
Match = re.match("^([_a-zA-Z0-9]+).([_a-zA-Z0-9]+)\s*\|\s*(0x[0-9A-F]+)(?:\s*\|\s*(.+))?", DscLine)
if Match:
ConfigDict['space'] = Match.group(1)
ConfigDict['cname'] = Match.group(2)
if Match.group(3) != '*':
Hardcode = True
Offset = int (Match.group(3), 16)
else:
AutoAlign = True
if Hardcode and AutoAlign:
print("Hardcode and auto-align mixed mode is not supported by GenCfgOpt")
raise SystemExit
ConfigDict['offset'] = Offset
if ConfigDict['order'] == -1:
ConfigDict['order'] = ConfigDict['offset'] << 8
else:
(Major, Minor) = ConfigDict['order'].split('.')
ConfigDict['order'] = (int (Major, 16) << 8 ) + int (Minor, 16)
if IsUpdSect:
Value = Match.group(5).strip()
if Match.group(4).startswith("0x"):
Length = int (Match.group(4), 16)
else :
Length = int (Match.group(4))
Offset += Length
else:
Value = Match.group(4)
if Value is None:
Value = ''
Value = Value.strip()
if '|' in Value:
Match = re.match("^.+\s*\|\s*(.+)", Value)
if Match:
Value = Match.group(1)
Length = -1
ConfigDict['length'] = Length
Match = re.match("\$\((\w+)\)", Value)
if Match:
if Match.group(1) in self._MacroDict:
Value = self._MacroDict[Match.group(1)]
ConfigDict['value'] = Value
if (len(Value) > 0) and (Value[0] == '{'):
Value = self.FormatListValue(ConfigDict)
if ConfigDict['name'] == '':
# Clear BSF specific items
ConfigDict['bsfname'] = ''
ConfigDict['help'] = ''
ConfigDict['type'] = ''
ConfigDict['option'] = ''
if IsUpdSect and AutoAlign:
ItemLength = int(ConfigDict['length'])
ItemOffset = int(ConfigDict['offset'])
ItemStruct = ConfigDict['struct']
Unit = 1
if ItemLength in [1, 2, 4, 8] and not ConfigDict['value'].startswith('{'):
Unit = ItemLength
# If there are 64 bit unit, align to 64
if Unit == 8:
MaxAlign = 64
SizeAlign = 8
if ItemStruct != '':
UnitDict = {'UINT8':1, 'UINT16':2, 'UINT32':4, 'UINT64':8}
if ItemStruct in ['UINT8', 'UINT16', 'UINT32', 'UINT64']:
Unit = UnitDict[ItemStruct]
# If there are 64 bit unit, align to 64
if Unit == 8:
MaxAlign = 64
SizeAlign = max(SizeAlign, Unit)
if (ConfigDict['embed'].find(':START') != -1):
Base = ItemOffset
SubOffset = ItemOffset - Base
SubRemainder = SubOffset % Unit
if SubRemainder:
Diff = Unit - SubRemainder
Offset = Offset + Diff
ItemOffset = ItemOffset + Diff
if (ConfigDict['embed'].find(':END') != -1):
Remainder = Offset % (MaxAlign/8) # MaxAlign is either 32 or 64
if Remainder:
Diff = (MaxAlign/8) - Remainder
Offset = Offset + Diff
ItemOffset = ItemOffset + Diff
MaxAlign = 32 # Reset to default 32 align when struct end
if (ConfigDict['cname'] == 'UpdTerminator'):
# ItemLength is the size of UpdTerminator
# Itemlength might be 16, 32, or 64
# Struct align to 64 if UpdTerminator
# or struct size is 64 bit, else align to 32
Remainder = Offset % max(ItemLength/8, 4, SizeAlign)
Offset = Offset + ItemLength
if Remainder:
Diff = max(ItemLength/8, 4, SizeAlign) - Remainder
ItemOffset = ItemOffset + Diff
ConfigDict['offset'] = ItemOffset
self._CfgItemList.append(ConfigDict.copy())
ConfigDict['name'] = ''
ConfigDict['find'] = ''
ConfigDict['struct'] = ''
ConfigDict['embed'] = ''
ConfigDict['comment'] = ''
ConfigDict['order'] = -1
ConfigDict['subreg'] = []
ConfigDict['option'] = ''
else:
# It could be a virtual item as below
# !BSF FIELD:{SerialDebugPortAddress0:1}
# or
# @Bsf FIELD:{SerialDebugPortAddress0:1b}
Match = re.match("^\s*#\s+(!BSF|@Bsf)\s+FIELD:{(.+):(\d+)([Bb])?}", DscLine)
if Match:
SubCfgDict = ConfigDict.copy()
if (Match.group(4) == None) or (Match.group(4) == 'B'):
UnitBitLen = 8
elif Match.group(4) == 'b':
UnitBitLen = 1
else:
print("ERROR: Invalide BSF FIELD length for line '%s'" % DscLine)
raise SystemExit
SubCfgDict['cname'] = Match.group(2)
SubCfgDict['bitlength'] = int (Match.group(3)) * UnitBitLen
if SubCfgDict['bitlength'] > 0:
LastItem = self._CfgItemList[-1]
if len(LastItem['subreg']) == 0:
SubOffset = 0
else:
SubOffset = LastItem['subreg'][-1]['bitoffset'] + LastItem['subreg'][-1]['bitlength']
SubCfgDict['bitoffset'] = SubOffset
LastItem['subreg'].append (SubCfgDict.copy())
ConfigDict['name'] = ''
return Error
def GetBsfBitFields (self, subitem, bytes):
start = subitem['bitoffset']
end = start + subitem['bitlength']
bitsvalue = ''.join('{0:08b}'.format(i) for i in bytes[::-1])
bitsvalue = bitsvalue[::-1]
bitslen = len(bitsvalue)
if start > bitslen or end > bitslen:
print ("Invalid bits offset [%d,%d] for %s" % (start, end, subitem['name']))
raise SystemExit
return hex(int(bitsvalue[start:end][::-1], 2))
def UpdateSubRegionDefaultValue (self):
Error = 0
for Item in self._CfgItemList:
if len(Item['subreg']) == 0:
continue
bytearray = []
if Item['value'][0] == '{':
binlist = Item['value'][1:-1].split(',')
for each in binlist:
each = each.strip()
if each.startswith('0x'):
value = int(each, 16)
else:
value = int(each)
bytearray.append(value)
else:
if Item['value'].startswith('0x'):
value = int(Item['value'], 16)
else:
value = int(Item['value'])
idx = 0
while idx < Item['length']:
bytearray.append(value & 0xFF)
value = value >> 8
idx = idx + 1
for SubItem in Item['subreg']:
valuestr = self.GetBsfBitFields(SubItem, bytearray)
SubItem['value'] = valuestr
return Error
def CreateSplitUpdTxt (self, UpdTxtFile):
GuidList = ['FSP_T_UPD_TOOL_GUID','FSP_M_UPD_TOOL_GUID','FSP_S_UPD_TOOL_GUID']
SignatureList = ['0x545F', '0x4D5F','0x535F'] # _T, _M, and _S signature for FSPT, FSPM, FSPS
for Index in range(len(GuidList)):
UpdTxtFile = ''
FvDir = self._FvDir
if GuidList[Index] not in self._MacroDict:
self.Error = "%s definition is missing in DSC file" % (GuidList[Index])
return 1
if UpdTxtFile == '':
UpdTxtFile = os.path.join(FvDir, self._MacroDict[GuidList[Index]] + '.txt')
ReCreate = False
if not os.path.exists(UpdTxtFile):
ReCreate = True
else:
DscTime = os.path.getmtime(self._DscFile)
TxtTime = os.path.getmtime(UpdTxtFile)
if DscTime > TxtTime:
ReCreate = True
if not ReCreate:
# DSC has not been modified yet
# So don't have to re-generate other files
self.Error = 'No DSC file change, skip to create UPD TXT file'
return 256
TxtFd = open(UpdTxtFile, "w")
TxtFd.write("%s\n" % (__copyright_txt__ % date.today().year))
NextOffset = 0
SpaceIdx = 0
StartAddr = 0
EndAddr = 0
Default = 'DEFAULT|'
InRange = False
for Item in self._CfgItemList:
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == SignatureList[Index]:
StartAddr = Item['offset']
NextOffset = StartAddr
InRange = True
if Item['cname'] == 'UpdTerminator' and InRange == True:
EndAddr = Item['offset']
InRange = False
InRange = False
for Item in self._CfgItemList:
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == SignatureList[Index]:
InRange = True
if InRange != True:
continue
if Item['cname'] == 'UpdTerminator':
InRange = False
if Item['region'] != 'UPD':
continue
Offset = Item['offset']
if StartAddr > Offset or EndAddr < Offset:
continue
if NextOffset < Offset:
# insert one line
TxtFd.write("%s.UnusedUpdSpace%d|%s0x%04X|0x%04X|{0}\n" % (Item['space'], SpaceIdx, Default, NextOffset - StartAddr, Offset - NextOffset))
SpaceIdx = SpaceIdx + 1
NextOffset = Offset + Item['length']
TxtFd.write("%s.%s|%s0x%04X|%s|%s\n" % (Item['space'],Item['cname'],Default,Item['offset'] - StartAddr,Item['length'],Item['value']))
TxtFd.close()
return 0
def ProcessMultilines (self, String, MaxCharLength):
Multilines = ''
StringLength = len(String)
CurrentStringStart = 0
StringOffset = 0
BreakLineDict = []
if len(String) <= MaxCharLength:
while (StringOffset < StringLength):
if StringOffset >= 1:
if String[StringOffset - 1] == '\\' and String[StringOffset] == 'n':
BreakLineDict.append (StringOffset + 1)
StringOffset += 1
if BreakLineDict != []:
for Each in BreakLineDict:
Multilines += " %s\n" % String[CurrentStringStart:Each].lstrip()
CurrentStringStart = Each
if StringLength - CurrentStringStart > 0:
Multilines += " %s\n" % String[CurrentStringStart:].lstrip()
else:
Multilines = " %s\n" % String
else:
NewLineStart = 0
NewLineCount = 0
FoundSpaceChar = False
while (StringOffset < StringLength):
if StringOffset >= 1:
if NewLineCount >= MaxCharLength - 1:
if String[StringOffset] == ' ' and StringLength - StringOffset > 10:
BreakLineDict.append (NewLineStart + NewLineCount)
NewLineStart = NewLineStart + NewLineCount
NewLineCount = 0
FoundSpaceChar = True
elif StringOffset == StringLength - 1 and FoundSpaceChar == False:
BreakLineDict.append (0)
if String[StringOffset - 1] == '\\' and String[StringOffset] == 'n':
BreakLineDict.append (StringOffset + 1)
NewLineStart = StringOffset + 1
NewLineCount = 0
StringOffset += 1
NewLineCount += 1
if BreakLineDict != []:
BreakLineDict.sort ()
for Each in BreakLineDict:
if Each > 0:
Multilines += " %s\n" % String[CurrentStringStart:Each].lstrip()
CurrentStringStart = Each
if StringLength - CurrentStringStart > 0:
Multilines += " %s\n" % String[CurrentStringStart:].lstrip()
return Multilines
def CreateField (self, Item, Name, Length, Offset, Struct, BsfName, Help, Option):
PosName = 28
PosComment = 30
NameLine=''
HelpLine=''
OptionLine=''
IsArray = False
if Length in [1,2,4,8]:
Type = "UINT%d" % (Length * 8)
if Name.startswith("UnusedUpdSpace") and Length != 1:
IsArray = True
Type = "UINT8"
else:
IsArray = True
Type = "UINT8"
if Item and Item['value'].startswith('{'):
Type = "UINT8"
IsArray = True
if Struct != '':
Type = Struct
if Struct in ['UINT8','UINT16','UINT32','UINT64']:
IsArray = True
Unit = int(Type[4:]) / 8
Length = Length / Unit
else:
IsArray = False
if IsArray:
Name = Name + '[%d]' % Length
if len(Type) < PosName:
Space1 = PosName - len(Type)
else:
Space1 = 1
if BsfName != '':
NameLine=" - %s\n" % BsfName
else:
NameLine="\n"
if Help != '':
HelpLine = self.ProcessMultilines (Help, 80)
if Option != '':
OptionLine = self.ProcessMultilines (Option, 80)
if Offset is None:
OffsetStr = '????'
else:
OffsetStr = '0x%04X' % Offset
return "\n/** Offset %s%s%s%s**/\n %s%s%s;\n" % (OffsetStr, NameLine, HelpLine, OptionLine, Type, ' ' * Space1, Name,)
def PostProcessBody (self, TextBody):
NewTextBody = []
OldTextBody = []
IncludeLine = False
StructName = ''
VariableName = ''
IsUpdHdrDefined = False
IsUpdHeader = False
for Line in TextBody:
SplitToLines = Line.splitlines()
MatchComment = re.match("^/\*\sCOMMENT:(\w+):([\w|\W|\s]+)\s\*/\s([\s\S]*)", SplitToLines[0])
if MatchComment:
if MatchComment.group(1) == 'FSP_UPD_HEADER':
IsUpdHeader = True
else:
IsUpdHeader = False
if IsUpdHdrDefined != True or IsUpdHeader != True:
CommentLine = " " + MatchComment.group(2) + "\n"
NewTextBody.append("/**" + CommentLine + "**/\n")
Line = Line[(len(SplitToLines[0]) + 1):]
Match = re.match("^/\*\sEMBED_STRUCT:(\w+):(\w+):(START|END)\s\*/\s([\s\S]*)", Line)
if Match:
Line = Match.group(4)
if Match.group(1) == 'FSP_UPD_HEADER':
IsUpdHeader = True
else:
IsUpdHeader = False
if Match and Match.group(3) == 'START':
if IsUpdHdrDefined != True or IsUpdHeader != True:
NewTextBody.append ('typedef struct {\n')
StructName = Match.group(1)
VariableName = Match.group(2)
MatchOffset = re.search('/\*\*\sOffset\s0x([a-fA-F0-9]+)', Line)
if MatchOffset:
Offset = int(MatchOffset.group(1), 16)
else:
Offset = None
Line
IncludeLine = True
OldTextBody.append (self.CreateField (None, VariableName, 0, Offset, StructName, '', '', ''))
if IncludeLine:
if IsUpdHdrDefined != True or IsUpdHeader != True:
NewTextBody.append (Line)
else:
OldTextBody.append (Line)
if Match and Match.group(3) == 'END':
if (StructName != Match.group(1)) or (VariableName != Match.group(2)):
print ("Unmatched struct name '%s' and '%s' !" % (StructName, Match.group(1)))
else:
if IsUpdHdrDefined != True or IsUpdHeader != True:
NewTextBody.append ('} %s;\n\n' % StructName)
IsUpdHdrDefined = True
IncludeLine = False
NewTextBody.extend(OldTextBody)
return NewTextBody
def WriteLinesWithoutTailingSpace (self, HeaderFd, Line):
TxtBody2 = Line.splitlines(True)
for Line2 in TxtBody2:
Line2 = Line2.rstrip()
Line2 += '\n'
HeaderFd.write (Line2)
return 0
def CreateHeaderFile (self, InputHeaderFile):
FvDir = self._FvDir
HeaderFileName = 'FspUpd.h'
HeaderFile = os.path.join(FvDir, HeaderFileName)
# Check if header needs to be recreated
ReCreate = False
TxtBody = []
for Item in self._CfgItemList:
if str(Item['cname']) == 'Signature' and Item['length'] == 8:
Value = int(Item['value'], 16)
Chars = []
while Value != 0x0:
Chars.append(chr(Value & 0xFF))
Value = Value >> 8
SignatureStr = ''.join(Chars)
# Signature will be _T / _M / _S for FSPT / FSPM / FSPS accordingly
if '_T' in SignatureStr[6:6+2]:
TxtBody.append("#define FSPT_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
elif '_M' in SignatureStr[6:6+2]:
TxtBody.append("#define FSPM_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
elif '_S' in SignatureStr[6:6+2]:
TxtBody.append("#define FSPS_UPD_SIGNATURE %s /* '%s' */\n\n" % (Item['value'], SignatureStr))
TxtBody.append("\n")
for Region in ['UPD']:
UpdOffsetTable = []
UpdSignature = ['0x545F', '0x4D5F', '0x535F'] #['_T', '_M', '_S'] signature for FSPT, FSPM, FSPS
UpdStructure = ['FSPT_UPD', 'FSPM_UPD', 'FSPS_UPD']
for Item in self._CfgItemList:
if Item["cname"] == 'Signature' and Item["value"][0:6] in UpdSignature:
UpdOffsetTable.append (Item["offset"])
for UpdIdx in range(len(UpdOffsetTable)):
CommentLine = ""
for Item in self._CfgItemList:
if Item["comment"] != '' and Item["offset"] >= UpdOffsetTable[UpdIdx]:
MatchComment = re.match("^(U|V)PD_DATA_REGION:([\w|\W|\s]+)", Item["comment"])
if MatchComment and MatchComment.group(1) == Region[0]:
CommentLine = " " + MatchComment.group(2) + "\n"
TxtBody.append("/**" + CommentLine + "**/\n")
elif Item["offset"] >= UpdOffsetTable[UpdIdx] and Item["comment"] == '':
Match = re.match("^FSP([\w|\W|\s])_UPD", UpdStructure[UpdIdx])
if Match:
TxtBody.append("/** Fsp " + Match.group(1) + " UPD Configuration\n**/\n")
TxtBody.append("typedef struct {\n")
NextOffset = 0
SpaceIdx = 0
Offset = 0
LastVisible = True
ResvOffset = 0
ResvIdx = 0
LineBuffer = []
InRange = False
for Item in self._CfgItemList:
if Item['cname'] == 'Signature' and str(Item['value'])[0:6] == UpdSignature[UpdIdx] or Region[0] == 'V':
InRange = True
if InRange != True:
continue
if Item['cname'] == 'UpdTerminator':
InRange = False
if Item['region'] != Region:
continue
if Item["offset"] < UpdOffsetTable[UpdIdx]:
continue
NextVisible = LastVisible
if LastVisible and (Item['header'] == 'OFF'):
NextVisible = False
ResvOffset = Item['offset']
elif (not LastVisible) and Item['header'] == 'ON':
NextVisible = True
Name = "Reserved" + Region[0] + "pdSpace%d" % ResvIdx
ResvIdx = ResvIdx + 1
TxtBody.append(self.CreateField (Item, Name, Item["offset"] - ResvOffset, ResvOffset, '', '', '', ''))
if Offset < Item["offset"]:
if LastVisible:
Name = "Unused" + Region[0] + "pdSpace%d" % SpaceIdx
LineBuffer.append(self.CreateField (Item, Name, Item["offset"] - Offset, Offset, '', '', '', ''))
SpaceIdx = SpaceIdx + 1
Offset = Item["offset"]
LastVisible = NextVisible
Offset = Offset + Item["length"]
if LastVisible:
for Each in LineBuffer:
TxtBody.append (Each)
LineBuffer = []
Comment = Item["comment"]
Embed = Item["embed"].upper()
if Embed.endswith(':START') or Embed.endswith(':END'):
if not Comment == '' and Embed.endswith(':START'):
Marker = '/* COMMENT:%s */ \n' % Item["comment"]
Marker = Marker + '/* EMBED_STRUCT:%s */ ' % Item["embed"]
else:
Marker = '/* EMBED_STRUCT:%s */ ' % Item["embed"]
else:
if Embed == '':
Marker = ''
else:
self.Error = "Invalid embedded structure format '%s'!\n" % Item["embed"]
return 4
Line = Marker + self.CreateField (Item, Item["cname"], Item["length"], Item["offset"], Item['struct'], Item['name'], Item['help'], Item['option'])
TxtBody.append(Line)
if Item['cname'] == 'UpdTerminator':
break
TxtBody.append("} " + UpdStructure[UpdIdx] + ";\n\n")
# Handle the embedded data structure
TxtBody = self.PostProcessBody (TxtBody)
HeaderTFileName = 'FsptUpd.h'
HeaderMFileName = 'FspmUpd.h'
HeaderSFileName = 'FspsUpd.h'
UpdRegionCheck = ['FSPT', 'FSPM', 'FSPS'] # FSPX_UPD_REGION
UpdConfigCheck = ['FSP_T', 'FSP_M', 'FSP_S'] # FSP_X_CONFIG, FSP_X_TEST_CONFIG, FSP_X_RESTRICTED_CONFIG
UpdSignatureCheck = ['FSPT_UPD_SIGNATURE', 'FSPM_UPD_SIGNATURE', 'FSPS_UPD_SIGNATURE']
ExcludedSpecificUpd = 'FSPM_ARCH_UPD'
if InputHeaderFile != '':
if not os.path.exists(InputHeaderFile):
self.Error = "Input header file '%s' does not exist" % InputHeaderFile
return 6
InFd = open(InputHeaderFile, "r")
IncLines = InFd.readlines()
InFd.close()
for item in range(len(UpdRegionCheck)):
if UpdRegionCheck[item] == 'FSPT':
HeaderFd = open(os.path.join(FvDir, HeaderTFileName), "w")
FileBase = os.path.basename(os.path.join(FvDir, HeaderTFileName))
elif UpdRegionCheck[item] == 'FSPM':
HeaderFd = open(os.path.join(FvDir, HeaderMFileName), "w")
FileBase = os.path.basename(os.path.join(FvDir, HeaderMFileName))
elif UpdRegionCheck[item] == 'FSPS':
HeaderFd = open(os.path.join(FvDir, HeaderSFileName), "w")
FileBase = os.path.basename(os.path.join(FvDir, HeaderSFileName))
FileName = FileBase.replace(".", "_").upper()
HeaderFd.write("%s\n" % (__copyright_h__ % date.today().year))
HeaderFd.write("#ifndef __%s__\n" % FileName)
HeaderFd.write("#define __%s__\n\n" % FileName)
HeaderFd.write("#include <%s>\n\n" % HeaderFileName)
HeaderFd.write("#pragma pack(1)\n\n")
Export = False
for Line in IncLines:
Match = re.search ("!EXPORT\s+([A-Z]+)\s+EXTERNAL_BOOTLOADER_STRUCT_(BEGIN|END)\s+", Line)
if Match:
if Match.group(2) == "BEGIN" and Match.group(1) == UpdRegionCheck[item]:
Export = True
continue
else:
Export = False
continue
if Export:
HeaderFd.write(Line)
HeaderFd.write("\n")
Index = 0
StartIndex = 0
EndIndex = 0
StructStart = []
StructStartWithComment = []
StructEnd = []
for Line in TxtBody:
Index += 1
Match = re.match("(typedef struct {)", Line)
if Match:
StartIndex = Index - 1
Match = re.match("}\s([_A-Z0-9]+);", Line)
if Match and (UpdRegionCheck[item] in Match.group(1) or UpdConfigCheck[item] in Match.group(1)) and (ExcludedSpecificUpd not in Match.group(1)):
EndIndex = Index
StructStart.append(StartIndex)
StructEnd.append(EndIndex)
Index = 0
for Line in TxtBody:
Index += 1
for Item in range(len(StructStart)):
if Index == StructStart[Item]:
Match = re.match("^(/\*\*\s*)", Line)
if Match:
StructStartWithComment.append(StructStart[Item])
else:
StructStartWithComment.append(StructStart[Item] + 1)
Index = 0
for Line in TxtBody:
Index += 1
for Item in range(len(StructStart)):
if Index >= StructStartWithComment[Item] and Index <= StructEnd[Item]:
self.WriteLinesWithoutTailingSpace(HeaderFd, Line)
HeaderFd.write("#pragma pack()\n\n")
HeaderFd.write("#endif\n")
HeaderFd.close()
HeaderFd = open(HeaderFile, "w")
FileBase = os.path.basename(HeaderFile)
FileName = FileBase.replace(".", "_").upper()
HeaderFd.write("%s\n" % (__copyright_h__ % date.today().year))
HeaderFd.write("#ifndef __%s__\n" % FileName)
HeaderFd.write("#define __%s__\n\n" % FileName)
HeaderFd.write("#include <FspEas.h>\n\n")
HeaderFd.write("#pragma pack(1)\n\n")
for item in range(len(UpdRegionCheck)):
Index = 0
StartIndex = 0
EndIndex = 0
StructStart = []
StructStartWithComment = []
StructEnd = []
for Line in TxtBody:
Index += 1
Match = re.match("(typedef struct {)", Line)
if Match:
StartIndex = Index - 1
Match = re.match("#define\s([_A-Z0-9]+)\s*", Line)
if Match and (UpdSignatureCheck[item] in Match.group(1) or UpdSignatureCheck[item] in Match.group(1)):
StructStart.append(Index - 1)
StructEnd.append(Index)
Index = 0
for Line in TxtBody:
Index += 1
for Item in range(len(StructStart)):
if Index == StructStart[Item]:
Match = re.match("^(/\*\*\s*)", Line)
if Match:
StructStartWithComment.append(StructStart[Item])
else:
StructStartWithComment.append(StructStart[Item] + 1)
Index = 0
for Line in TxtBody:
Index += 1
for Item in range(len(StructStart)):
if Index >= StructStartWithComment[Item] and Index <= StructEnd[Item]:
self.WriteLinesWithoutTailingSpace(HeaderFd, Line)
HeaderFd.write("#pragma pack()\n\n")
HeaderFd.write("#endif\n")
HeaderFd.close()
return 0
def WriteBsfStruct (self, BsfFd, Item):
LogExpr = CLogicalExpression()
if Item['type'] == "None":
Space = "gPlatformFspPkgTokenSpaceGuid"
else:
Space = Item['space']
Line = " $%s_%s" % (Space, Item['cname'])
Match = re.match("\s*\{([x0-9a-fA-F,\s]+)\}\s*", Item['value'])
if Match:
DefaultValue = Match.group(1).strip()
else:
DefaultValue = Item['value'].strip()
if 'bitlength' in Item:
BsfFd.write(" %s%s%4d bits $_DEFAULT_ = %s\n" % (Line, ' ' * (64 - len(Line)), Item['bitlength'], DefaultValue))
else:
BsfFd.write(" %s%s%4d bytes $_DEFAULT_ = %s\n" % (Line, ' ' * (64 - len(Line)), Item['length'], DefaultValue))
TmpList = []
if Item['type'] == "Combo":
if not Item['option'] in self._BuidinOption:
OptList = Item['option'].split(',')
for Option in OptList:
Option = Option.strip()
(OpVal, OpStr) = Option.split(':')
test = LogExpr.getNumber (OpVal)
if test is None:
raise Exception("Selection Index '%s' is not a number" % OpVal)
TmpList.append((OpVal, OpStr))
return TmpList
def WriteBsfOption (self, BsfFd, Item):
PcdName = Item['space'] + '_' + Item['cname']
WriteHelp = 0
if Item['type'] == "Combo":
if Item['option'] in self._BuidinOption:
Options = self._BuidinOption[Item['option']]
else:
Options = PcdName
BsfFd.write(' %s $%s, "%s", &%s,\n' % (Item['type'], PcdName, Item['name'], Options))
WriteHelp = 1
elif Item['type'].startswith("EditNum"):
Match = re.match("EditNum\s*,\s*(HEX|DEC)\s*,\s*\((\d+|0x[0-9A-Fa-f]+)\s*,\s*(\d+|0x[0-9A-Fa-f]+)\)", Item['type'])
if Match:
BsfFd.write(' EditNum $%s, "%s", %s,\n' % (PcdName, Item['name'], Match.group(1)))
WriteHelp = 2
elif Item['type'].startswith("EditText"):
BsfFd.write(' %s $%s, "%s",\n' % (Item['type'], PcdName, Item['name']))
WriteHelp = 1
elif Item['type'] == "Table":
Columns = Item['option'].split(',')
if len(Columns) != 0:
BsfFd.write(' %s $%s "%s",' % (Item['type'], PcdName, Item['name']))
for Col in Columns:
Fmt = Col.split(':')
if len(Fmt) != 3:
raise Exception("Column format '%s' is invalid !" % Fmt)
try:
Dtype = int(Fmt[1].strip())
except:
raise Exception("Column size '%s' is invalid !" % Fmt[1])
BsfFd.write('\n Column "%s", %d bytes, %s' % (Fmt[0].strip(), Dtype, Fmt[2].strip()))
BsfFd.write(',\n')
WriteHelp = 1
if WriteHelp > 0:
HelpLines = Item['help'].split('\\n\\r')
FirstLine = True
for HelpLine in HelpLines:
if FirstLine:
FirstLine = False
BsfFd.write(' Help "%s"\n' % (HelpLine))
else:
BsfFd.write(' "%s"\n' % (HelpLine))
if WriteHelp == 2:
BsfFd.write(' "Valid range: %s ~ %s"\n' % (Match.group(2), Match.group(3)))
def GenerateBsfFile (self, BsfFile):
if BsfFile == '':
self.Error = "BSF output file '%s' is invalid" % BsfFile
return 1
Error = 0
OptionDict = {}
BsfFd = open(BsfFile, "w")
BsfFd.write("%s\n" % (__copyright_bsf__ % date.today().year))
BsfFd.write("%s\n" % self._GlobalDataDef)
BsfFd.write("StructDef\n")
NextOffset = -1
for Item in self._CfgItemList:
if Item['find'] != '':
BsfFd.write('\n Find "%s"\n' % Item['find'])
NextOffset = Item['offset'] + Item['length']
if Item['name'] != '':
if NextOffset != Item['offset']:
BsfFd.write(" Skip %d bytes\n" % (Item['offset'] - NextOffset))
if len(Item['subreg']) > 0:
NextOffset = Item['offset']
BitsOffset = NextOffset * 8
for SubItem in Item['subreg']:
BitsOffset += SubItem['bitlength']
if SubItem['name'] == '':
if 'bitlength' in SubItem:
BsfFd.write(" Skip %d bits\n" % (SubItem['bitlength']))
else:
BsfFd.write(" Skip %d bytes\n" % (SubItem['length']))
else:
Options = self.WriteBsfStruct(BsfFd, SubItem)
if len(Options) > 0:
OptionDict[SubItem['space']+'_'+SubItem['cname']] = Options
NextBitsOffset = (Item['offset'] + Item['length']) * 8
if NextBitsOffset > BitsOffset:
BitsGap = NextBitsOffset - BitsOffset
BitsRemain = BitsGap % 8
if BitsRemain:
BsfFd.write(" Skip %d bits\n" % BitsRemain)
BitsGap -= BitsRemain
BytesRemain = BitsGap / 8
if BytesRemain:
BsfFd.write(" Skip %d bytes\n" % BytesRemain)
NextOffset = Item['offset'] + Item['length']
else:
NextOffset = Item['offset'] + Item['length']
Options = self.WriteBsfStruct(BsfFd, Item)
if len(Options) > 0:
OptionDict[Item['space']+'_'+Item['cname']] = Options
BsfFd.write("\nEndStruct\n\n")
BsfFd.write("%s" % self._BuidinOptionTxt)
for Each in OptionDict:
BsfFd.write("List &%s\n" % Each)
for Item in OptionDict[Each]:
BsfFd.write(' Selection %s , "%s"\n' % (Item[0], Item[1]))
BsfFd.write("EndList\n\n")
BsfFd.write("BeginInfoBlock\n")
BsfFd.write(' PPVer "%s"\n' % (self._CfgBlkDict['ver']))
BsfFd.write(' Description "%s"\n' % (self._CfgBlkDict['name']))
BsfFd.write("EndInfoBlock\n\n")
for Each in self._CfgPageDict:
BsfFd.write('Page "%s"\n' % self._CfgPageDict[Each])
BsfItems = []
for Item in self._CfgItemList:
if Item['name'] != '':
if Item['page'] != Each:
continue
if len(Item['subreg']) > 0:
for SubItem in Item['subreg']:
if SubItem['name'] != '':
BsfItems.append(SubItem)
else:
BsfItems.append(Item)
BsfItems.sort(key=lambda x: x['order'])
for Item in BsfItems:
self.WriteBsfOption (BsfFd, Item)
BsfFd.write("EndPage\n\n")
BsfFd.close()
return Error
def Usage():
print ("GenCfgOpt Version 0.54")
print ("Usage:")
print (" GenCfgOpt UPDTXT PlatformDscFile BuildFvDir [-D Macros]")
print (" GenCfgOpt HEADER PlatformDscFile BuildFvDir InputHFile [-D Macros]")
print (" GenCfgOpt GENBSF PlatformDscFile BuildFvDir BsfOutFile [-D Macros]")
def Main():
#
# Parse the options and args
#
i = 1
GenCfgOpt = CGenCfgOpt()
while i < len(sys.argv):
if sys.argv[i].strip().lower() == "--pcd":
BuildOptionPcd.append(sys.argv[i+1])
i += 1
i += 1
argc = len(sys.argv)
if argc < 4:
Usage()
return 1
else:
DscFile = sys.argv[2]
if not os.path.exists(DscFile):
print ("ERROR: Cannot open DSC file '%s' !" % DscFile)
return 2
OutFile = ''
if argc > 4:
if sys.argv[4][0] == '-':
Start = 4
else:
OutFile = sys.argv[4]
Start = 5
if argc > Start:
if GenCfgOpt.ParseMacros(sys.argv[Start:]) != 0:
print ("ERROR: Macro parsing failed !")
return 3
FvDir = sys.argv[3]
if not os.path.exists(FvDir):
os.makedirs(FvDir)
if GenCfgOpt.ParseDscFile(DscFile, FvDir) != 0:
print ("ERROR: %s !" % GenCfgOpt.Error)
return 5
if GenCfgOpt.UpdateSubRegionDefaultValue() != 0:
print ("ERROR: %s !" % GenCfgOpt.Error)
return 7
if sys.argv[1] == "UPDTXT":
Ret = GenCfgOpt.CreateSplitUpdTxt(OutFile)
if Ret != 0:
# No change is detected
if Ret == 256:
print ("INFO: %s !" % (GenCfgOpt.Error))
else :
print ("ERROR: %s !" % (GenCfgOpt.Error))
return Ret
elif sys.argv[1] == "HEADER":
if GenCfgOpt.CreateHeaderFile(OutFile) != 0:
print ("ERROR: %s !" % GenCfgOpt.Error)
return 8
elif sys.argv[1] == "GENBSF":
if GenCfgOpt.GenerateBsfFile(OutFile) != 0:
print ("ERROR: %s !" % GenCfgOpt.Error)
return 9
else:
if argc < 5:
Usage()
return 1
print ("ERROR: Unknown command '%s' !" % sys.argv[1])
Usage()
return 1
return 0
return 0
if __name__ == '__main__':
sys.exit(Main())
| 43.672258 | 171 | 0.44308 |
925efe3c2928301477b98f3cd1b22f0bd9394b4f | 8,178 | py | Python | src/falconpy/_endpoint/_ioc.py | aneisch/falconpy | d6b9f96dce964919dced2628dbf0c6adc55b4952 | [
"Unlicense"
]
| null | null | null | src/falconpy/_endpoint/_ioc.py | aneisch/falconpy | d6b9f96dce964919dced2628dbf0c6adc55b4952 | [
"Unlicense"
]
| null | null | null | src/falconpy/_endpoint/_ioc.py | aneisch/falconpy | d6b9f96dce964919dced2628dbf0c6adc55b4952 | [
"Unlicense"
]
| null | null | null | """
_______ __ _______ __ __ __
| _ .----.-----.--.--.--.--| | _ | |_.----|__| |--.-----.
|. 1___| _| _ | | | | _ | 1___| _| _| | <| -__|
|. |___|__| |_____|________|_____|____ |____|__| |__|__|__|_____|
|: 1 | |: 1 |
|::.. . | CROWDSTRIKE FALCON |::.. . | FalconPy
`-------' `-------'
OAuth2 API - Customer SDK
_endpoint._ioc - Internal API endpoint constant library
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
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 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.
For more information, please refer to <https://unlicense.org>
"""
_ioc_endpoints = [
[
"indicator_combined_v1",
"GET",
"/iocs/combined/indicator/v1",
"Get Combined for Indicators.",
"ioc",
[
{
"type": "string",
"description": "The filter expression that should be used to limit the results.",
"name": "filter",
"in": "query"
},
{
"type": "integer",
"description": "The offset to start retrieving records from. Offset and After params are mutually exclusive. "
"If none provided then scrolling will be used by default.",
"name": "offset",
"in": "query"
},
{
"type": "string",
"description": "A pagination token used with the `limit` parameter to manage pagination "
"of results. On your first request, don't provide an `after` token. On subsequent requests, "
"provide the `after` token from the previous response to continue from that place in the results.",
"name": "after",
"in": "query"
},
{
"type": "integer",
"description": "The maximum records to return.",
"name": "limit",
"in": "query"
},
{
"enum": [
"action",
"applied_globally",
"metadata.av_hits",
"metadata.company_name.raw",
"created_by",
"created_on",
"expiration",
"expired",
"metadata.filename.raw",
"modified_by",
"modified_on",
"metadata.original_filename.raw",
"metadata.product_name.raw",
"metadata.product_version",
"severity_number",
"source",
"type",
"value"
],
"type": "string",
"description": "The sort expression that should be used to sort the results.",
"name": "sort",
"in": "query"
}
]
],
[
"indicator_get_v1",
"GET",
"/iocs/entities/indicators/v1?ids={}",
"Get Indicators by ids.",
"ioc",
[
{
"type": "array",
"items": {
"type": "string"
},
"collectionFormat": "csv",
"description": "The ids of the Indicators to retrieve",
"name": "ids",
"in": "query",
"required": True
}
]
],
[
"indicator_create_v1",
"POST",
"/iocs/entities/indicators/v1",
"Create Indicators.",
"ioc",
[
{
"type": "string",
"description": "The username",
"name": "X-CS-USERNAME",
"in": "header"
},
{
"type": "bool",
"description": "Whether to submit to retrodetects",
"name": "retrodetects",
"in": "query"
},
{
"type": "bool",
"default": False,
"description": "Set to true to ignore warnings and add all IOCs",
"name": "ignore_warnings",
"in": "query"
},
{
"name": "body",
"in": "body",
"required": True
}
]
],
[
"indicator_update_v1",
"PATCH",
"/iocs/entities/indicators/v1",
"Update Indicators.",
"ioc",
[
{
"type": "string",
"description": "The username",
"name": "X-CS-USERNAME",
"in": "header"
},
{
"type": "bool",
"description": "Whether to submit to retrodetects",
"name": "retrodetects",
"in": "query"
},
{
"type": "bool",
"default": False,
"description": "Set to true to ignore warnings and add all IOCs",
"name": "ignore_warnings",
"in": "query"
},
{
"name": "body",
"in": "body",
"required": True
}
]
],
[
"indicator_delete_v1",
"DELETE",
"/iocs/entities/indicators/v1",
"Delete Indicators by ids.",
"ioc",
[
{
"type": "string",
"description": "The FQL expression to delete Indicators in bulk. If both 'filter' and 'ids' are provided, "
"then filter takes precedence and ignores ids.",
"name": "filter",
"in": "query"
},
{
"type": "array",
"items": {
"type": "string"
},
"collectionFormat": "csv",
"description": "The ids of the Indicators to delete. If both 'filter' and 'ids' are provided, "
"then filter takes precedence and ignores ids",
"name": "ids",
"in": "query"
},
{
"type": "string",
"description": "The comment why these indicators were deleted",
"name": "comment",
"in": "query"
}
]
],
[
"indicator_search_v1",
"GET",
"/iocs/queries/indicators/v1",
"Search for Indicators.",
"ioc",
[
{
"type": "string",
"description": "The filter expression that should be used to limit the results.",
"name": "filter",
"in": "query"
},
{
"type": "integer",
"description": "The offset to start retrieving records from. Offset and After params are mutually exclusive. "
"If none provided then scrolling will be used by default.",
"name": "offset",
"in": "query"
},
{
"type": "string",
"description": "A pagination token used with the `limit` parameter to manage pagination "
"of results. On your first request, don't provide an `after` token. On subsequent requests, "
"provide the `after` token from the previous response to continue from that place in the results.",
"name": "after",
"in": "query"
},
{
"type": "integer",
"description": "The maximum records to return.",
"name": "limit",
"in": "query"
},
{
"enum": [
"action",
"applied_globally",
"metadata.av_hits",
"metadata.company_name.raw",
"created_by",
"created_on",
"expiration",
"expired",
"metadata.filename.raw",
"modified_by",
"modified_on",
"metadata.original_filename.raw",
"metadata.product_name.raw",
"metadata.product_version",
"severity_number",
"source",
"type",
"value"
],
"type": "string",
"description": "The sort expression that should be used to sort the results.",
"name": "sort",
"in": "query"
}
]
]
]
| 28.694737 | 118 | 0.532282 |
9797dc33b44e1c82fb5aa299b30429399deef5d1 | 831 | py | Python | code-pool/insertion-sort7.py | ColorOfLight/kaist-musynth | 98bf12cfac0722e15db2e9a8e01275b002e7bdf3 | [
"MIT"
]
| 1 | 2021-09-06T03:09:40.000Z | 2021-09-06T03:09:40.000Z | code-pool/insertion-sort7.py | ColorOfLight/kaist-musynth | 98bf12cfac0722e15db2e9a8e01275b002e7bdf3 | [
"MIT"
]
| null | null | null | code-pool/insertion-sort7.py | ColorOfLight/kaist-musynth | 98bf12cfac0722e15db2e9a8e01275b002e7bdf3 | [
"MIT"
]
| null | null | null | # Insertion Sort - Part 2
# The method insertionSort takes in one parameter: ar, an unsorted array. Use an Insertion Sort Algorithm to sort the entire array.
#!/bin/python
import sys
# Head ends here
def insertionSort(ar):
output = ""
i = 1
done = False
ar[0] = int(ar[0])
while i < len(ar):
done = False
toInsert = int(ar.pop(i))
j = 0
while j < i and not(done):
if ar[j] > toInsert:
ar.insert(j, toInsert);
done = True
j += 1
if(not(done) and j != len(ar)):
ar.insert(j, toInsert)
elif(not(done)):
ar.append(toInsert)
i += 1
for val in ar:
output += str(int(val)) + " "
output += "\n"
return output.strip();
# Tail starts here
length = int(sys.stdin.readline())
array = sys.stdin.readline().split(' ')
print(insertionSort(array[0:length])) | 21.868421 | 132 | 0.602888 |
74fc781574d5e235a9556c565751f7a97df29bd0 | 9,409 | py | Python | chroma/cache.py | NuTufts/chroma_lartpc | ea6d1a62d22eeeaac069efdef1068a56be683fcc | [
"BSD-3-Clause"
]
| null | null | null | chroma/cache.py | NuTufts/chroma_lartpc | ea6d1a62d22eeeaac069efdef1068a56be683fcc | [
"BSD-3-Clause"
]
| null | null | null | chroma/cache.py | NuTufts/chroma_lartpc | ea6d1a62d22eeeaac069efdef1068a56be683fcc | [
"BSD-3-Clause"
]
| null | null | null | '''chroma.cache: On-disk geometry and bounding volume hierarchy cache.
The ``Cache`` class is used to manage an on-disk cache of geometry and
BVH objects, which are slow to calculate. By default, the cache is in
$HOME/.chroma.
Currently this cache is not thread or process-safe when a writing
process is present.
'''
import os
import cPickle as pickle
import copy
#from chroma.log import logger
import logging
logger = logging.getLogger(__name__)
class GeometryNotFoundError(Exception):
'''A requested geometry was not found in the on-disk cache.'''
def __init__(self, msg):
Exception.__init__(self, msg)
class BVHNotFoundError(Exception):
'''A requested bounding volume hierarchy was not found in the
on-disk cache.'''
def __init__(self, msg):
Exception.__init__(self, msg)
def verify_or_create_dir(dirname, exception_msg, logger_msg=None):
'''Checks if ``dirname`` exists and is a directory. If it does not exist,
then it is created. If it does exist, but is not a directory, an IOError
is raised with ``exception_message`` as the description.
If the directory is created, an info message will be sent to the
Chroma logger if ``logger_message`` is not None.
'''
if not os.path.isdir(dirname):
if os.path.exists(dirname):
raise IOError(exception_msg)
else:
if logger_msg is not None:
logger.info(logger_msg)
os.mkdir(dirname)
class Cache(object):
'''Class for manipulating a Chroma disk cache directory.
Use this class to read and write cached geometries or bounding
volume hierarchies rather than reading and writing disk directly.
Cached geometries are accessed by a name string. The name of a
geometry should be a legal Python identifier that does not start
with an underscore. (Note that the name string is directly
mapped to a filename, so beware of taking Cache names from untrusted
sources. Don't let Little Bobby Tables ruin your day.)
Bounding volume hierarchies are accessed by MD5 hash of the
flattened geometry mesh using the hexadecimal string provided by
Mesh.md5(). Multiple BVHs are possible for a given mesh, so the
BVH can also be given an optional name (legal Python identifier,
no underscore as with geometries). The version of the BVH
with the special name "default" will be the default BVH.
'''
def __init__(self, cache_dir=os.path.expanduser('~/.chroma/')):
'''Open a Chroma cache stored at ``cache_dir``.
If ``cache_dir`` does not already exist, it will be created. By default,
the cache is in the ``.chroma`` directory under the user's home directory.
'''
self.cache_dir = cache_dir
verify_or_create_dir(self.cache_dir,
exception_msg='Path for cache already exists, '
'but is not a directory: %s' % cache_dir,
logger_msg='Creating new Chroma cache directory at %s'
% cache_dir)
self.geo_dir = os.path.join(cache_dir, 'geo')
verify_or_create_dir(self.geo_dir,
exception_msg='Path for geometry directory in cache '
'already exists, but is not a directory: %s'
% self.geo_dir)
self.bvh_dir = os.path.join(cache_dir, 'bvh')
verify_or_create_dir(self.bvh_dir,
exception_msg='Path for BVH directory in cache already '
'exists, but is not a directory: %s' % self.bvh_dir)
def get_geometry_filename(self, name):
'''Return the full pathname for the geometry file corresponding to
``name``.
'''
return os.path.join(self.geo_dir, name)
def list_geometry(self):
'''Returns a list of all geometry names in the cache.'''
return os.listdir(self.geo_dir)
def save_geometry(self, name, geometry):
'''Save ``geometry`` in the cache with the name ``name``.'''
geo_file = self.get_geometry_filename(name)
# exclude saving the BVH
reduced_geometry = copy.copy(geometry)
reduced_geometry.bvh = None
reduced_geometry.solids = []
reduced_geometry.solid_rotations = []
reduced_geometry.solid_displacements = []
with open(geo_file, 'wb') as output_file:
pickle.dump(geometry.mesh.md5(), output_file,
pickle.HIGHEST_PROTOCOL)
pickle.dump(reduced_geometry, output_file,
pickle.HIGHEST_PROTOCOL)
def load_geometry(self, name):
'''Returns the chroma.geometry.Geometry object associated with
``name`` in the cache.
Raises ``GeometryNotFoundError`` if ``name`` is not in the cache.
'''
geo_file = self.get_geometry_filename(name)
if not os.path.exists(geo_file):
raise GeometryNotFoundError(name)
with open(geo_file, 'rb') as input_file:
_ = pickle.load(input_file) # skip mesh hash
geo = pickle.load(input_file)
return geo
def remove_geometry(self, name):
'''Remove the geometry file associated with ``name`` from the cache.
If ``name`` does not exist, no action is taken.
'''
geo_file = self.get_geometry_filename(name)
if os.path.exists(geo_file):
os.remove(geo_file)
def get_geometry_hash(self, name):
'''Get the mesh hash for the geometry associated with ``name``.
This is faster than loading the entire geometry file and calling the
hash() method on the mesh.
'''
geo_file = self.get_geometry_filename(name)
if not os.path.exists(geo_file):
raise GeometryNotFoundError(name)
with open(geo_file, 'rb') as input_file:
return pickle.load(input_file)
def load_default_geometry(self):
'''Load the default geometry as set by previous call to
set_default_geometry().
If no geometry has been designated the default, raise
GeometryNotFoundError.
'''
return self.load_geometry('.default')
def set_default_geometry(self, name):
'''Set the geometry in the cache corresponding to ``name`` to
be the default geometry returned by load_default_geometry().
'''
default_geo_file = self.get_geometry_filename('.default')
geo_file = self.get_geometry_filename(name)
if not os.path.exists(geo_file):
raise GeometryNotFoundError(name)
if os.path.exists(default_geo_file):
if os.path.islink(default_geo_file):
os.remove(default_geo_file)
else:
raise IOError('Non-symlink found where expected a symlink: '
+default_geo_file)
os.symlink(geo_file, default_geo_file)
def get_bvh_directory(self, mesh_hash):
'''Return the full path to the directory corresponding to
``mesh_hash``.
'''
return os.path.join(self.bvh_dir, mesh_hash)
def get_bvh_filename(self, mesh_hash, name='default'):
'''Return the full pathname for the BVH file corresponding to
``name``.
'''
return os.path.join(self.get_bvh_directory(mesh_hash), name)
def list_bvh(self, mesh_hash):
'''Returns a list the names of all BVHs corresponding to
``mesh_hash``.
'''
bvh_dir = self.get_bvh_directory(mesh_hash)
if not os.path.isdir(bvh_dir):
return []
else:
return os.listdir(bvh_dir)
def exist_bvh(self, mesh_hash, name='default'):
'''Returns True if a cached BVH exists corresponding to
``mesh_hash`` with the given ``name``.
'''
return os.path.isfile(self.get_bvh_filename(mesh_hash, name))
def save_bvh(self, bvh, mesh_hash, name='default'):
'''Saves the given chroma.bvh.BVH object to the cache, tagged
by the given ``mesh_hash`` and ``name``.
'''
bvh_dir = self.get_bvh_directory(mesh_hash)
verify_or_create_dir(bvh_dir,
exception_msg='Non-directory already exists '
'where BVH directory should go: ' + bvh_dir)
bvh_file = self.get_bvh_filename(mesh_hash, name)
with open(bvh_file, 'wb') as output_file:
pickle.dump(bvh, output_file,
pickle.HIGHEST_PROTOCOL)
def load_bvh(self, mesh_hash, name='default'):
'''Returns the chroma.bvh.BVH object corresponding to ``mesh_hash``
and the given ``name``.
If no BVH exists, raises ``BVHNotFoundError``.
'''
bvh_file = self.get_bvh_filename(mesh_hash, name)
if not os.path.exists(bvh_file):
raise BVHNotFoundError(mesh_hash + ':' + name)
with open(bvh_file, 'rb') as input_file:
bvh = pickle.load(input_file)
return bvh
def remove_bvh(self, mesh_hash, name='default'):
'''Remove the BVH file associated with ``mesh_hash`` and
``name`` from the cache.
If the BVH does not exist, no action is taken.
'''
bvh_file = self.get_bvh_filename(mesh_hash, name)
if os.path.exists(bvh_file):
os.remove(bvh_file)
| 38.093117 | 82 | 0.631098 |
42e84bee6485327a161eaad33ceb8910443d897f | 1,876 | py | Python | bases_2021_1S/Grupo 01/UNION/Server/Parser/analizer/statement/instructions/truncate.py | dadu0699/tytus | e1920f6932c840859e3e79eb8756a1d3da88bd77 | [
"MIT"
]
| 35 | 2020-12-07T03:11:43.000Z | 2021-04-15T17:38:16.000Z | bases_2021_1S/Grupo 01/UNION/Server/Parser/analizer/statement/instructions/truncate.py | dadu0699/tytus | e1920f6932c840859e3e79eb8756a1d3da88bd77 | [
"MIT"
]
| 47 | 2020-12-09T01:29:09.000Z | 2021-01-13T05:37:50.000Z | bases_2021_1S/Grupo 01/UNION/Server/Parser/analizer/statement/instructions/truncate.py | dadu0699/tytus | e1920f6932c840859e3e79eb8756a1d3da88bd77 | [
"MIT"
]
| 556 | 2020-12-07T03:13:31.000Z | 2021-06-17T17:41:10.000Z | from Parser.analizer.reports import Nodo
from Parser.storage.storageManager import jsonMode
from Parser.analizer.abstract import instruction
class Truncate(instruction.Instruction):
def __init__(self, name, row, column):
instruction.Instruction.__init__(self, row, column)
self.name = name
def execute(self, environment):
try:
valor = jsonMode.truncate(instruction.dbtemp, self.name)
if valor == 2:
instruction.semanticErrors.append(
[
"La base de datos " + str(instruction.dbtemp) + " no existe ",
self.row,
]
)
instruction.syntaxPostgreSQL.append(
"Error: 42000: La base de datos "
+ str(instruction.dbtemp)
+ " no existe"
)
return "La base de datos no existe"
if valor == 3:
instruction.semanticErrors.append(
["La tabla " + str(self.name) + " no existe ", self.row]
)
instruction.syntaxPostgreSQL.append(
"Error: 42P01: La tabla " + str(self.name) + " no existe"
)
return "El nombre de la tabla no existe"
if valor == 1:
instruction.syntaxPostgreSQL.append("Error: XX000: Error interno")
return "Hubo un problema en la ejecucion de la sentencia"
if valor == 0:
return "Truncate de la tabla: " + self.name
except:
instruction.syntaxPostgreSQL.append(
"Error: P0001: Error en la instruccion TRUNCATE"
)
def dot(self):
new = Nodo.Nodo("TRUNCATE")
n = Nodo.Nodo(self.name)
new.addNode(n)
return new
| 37.52 | 86 | 0.520256 |
cd8d89817a8a9c1b017d5d84023ef64f99a4c532 | 1,114 | py | Python | modules/sdl2/audio/__init__.py | rave-engine/rave | 0eeb956363f4d7eda92350775d7d386550361273 | [
"BSD-2-Clause"
]
| 5 | 2015-03-18T01:19:56.000Z | 2020-10-23T12:44:47.000Z | modules/sdl2/audio/__init__.py | rave-engine/rave | 0eeb956363f4d7eda92350775d7d386550361273 | [
"BSD-2-Clause"
]
| null | null | null | modules/sdl2/audio/__init__.py | rave-engine/rave | 0eeb956363f4d7eda92350775d7d386550361273 | [
"BSD-2-Clause"
]
| null | null | null | """
rave audio backend using the SDL2 library.
"""
import sys
import sdl2
import sdl2.ext
import sdl2.sdlmixer as sdl2mixer
import rave.log
import rave.events
import rave.backends
import rave.resources
from ..common import fs_to_rwops
from . import formats
__author__ = 'Shiz'
__provides__ = [ 'audio' ]
BACKEND_PRIORITY = 50
def load():
rave.backends.register(rave.backends.BACKEND_AUDIO, sys.modules[__name__])
def unload():
rave.backends.remove(rave.backends.BACKEND_AUDIO, sys.modules[__name__])
def load_backend(category):
global _formats
if sdl2.SDL_InitSubSystem(sdl2.SDL_INIT_AUDIO) != 0:
return False
_formats = sdl2mixer.Mix_Init(sum(formats.FORMAT_NAMES))
if not _formats:
return False
rave.events.hook('engine.new_game', new_game)
return True
def unload_backend(category):
sdl2mixer.Mix_Quit()
sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_AUDIO)
def handle_events():
pass
## Backend stuff.
def new_game(event, game):
formats.register_loaders(game.resources)
## Internals.
_log = rave.log.get(__name__)
_formats = 0
| 18.566667 | 78 | 0.728007 |
398e8b0aa3a55b3a35ca9c3bb819815021496a9a | 5,166 | py | Python | example/timeline_example.py | Chaos-Chou/pyecharts | 7c510015e5bfecf28bc7ec2945a987e03e168d64 | [
"MIT"
]
| 1 | 2020-02-10T04:56:33.000Z | 2020-02-10T04:56:33.000Z | example/timeline_example.py | Chaos-Chou/pyecharts | 7c510015e5bfecf28bc7ec2945a987e03e168d64 | [
"MIT"
]
| null | null | null | example/timeline_example.py | Chaos-Chou/pyecharts | 7c510015e5bfecf28bc7ec2945a987e03e168d64 | [
"MIT"
]
| null | null | null | from pyecharts.commons.utils import JsCode
from pyecharts import options as opts
from pyecharts.charts import Bar, Map, Page, Pie, Sankey, Timeline
from pyecharts.faker import Collector, Faker
C = Collector()
@C.funcs
def timeline_bar() -> Timeline:
x = Faker.choose()
tl = Timeline()
for i in range(2015, 2020):
bar = (
Bar()
.add_xaxis(x)
.add_yaxis("商家A", Faker.values())
.add_yaxis("商家B", Faker.values())
.set_global_opts(title_opts=opts.TitleOpts("某商店{}年营业额".format(i)))
)
tl.add(bar, "{}年".format(i))
return tl
@C.funcs
def timeline_bar_with_graphic() -> Timeline:
x = Faker.choose()
tl = Timeline()
for i in range(2015, 2020):
bar = (
Bar()
.add_xaxis(x)
.add_yaxis("商家A", Faker.values())
.add_yaxis("商家B", Faker.values())
.set_global_opts(
title_opts=opts.TitleOpts("某商店{}年营业额 - With Graphic 组件".format(i)),
graphic_opts=[
opts.GraphicGroup(
graphic_item=opts.GraphicItem(
rotation=JsCode("Math.PI / 4"),
bounding="raw",
right=100,
bottom=110,
z=100,
),
children=[
opts.GraphicRect(
graphic_item=opts.GraphicItem(
left="center", top="center", z=100
),
graphic_shape_opts=opts.GraphicShapeOpts(
width=400, height=50
),
graphic_basicstyle_opts=opts.GraphicBasicStyleOpts(
fill="rgba(0,0,0,0.3)"
),
),
opts.GraphicText(
graphic_item=opts.GraphicItem(
left="center", top="center", z=100
),
graphic_textstyle_opts=opts.GraphicTextStyleOpts(
text="某商店{}年营业额".format(i),
font="bold 26px Microsoft YaHei",
graphic_basicstyle_opts=opts.GraphicBasicStyleOpts(
fill="#fff"
),
),
),
],
)
],
)
)
tl.add(bar, "{}年".format(i))
return tl
@C.funcs
def timeline_pie() -> Timeline:
attr = Faker.choose()
tl = Timeline()
for i in range(2015, 2020):
pie = (
Pie()
.add(
"商家A",
[list(z) for z in zip(attr, Faker.values())],
rosetype="radius",
radius=["30%", "55%"],
)
.set_global_opts(title_opts=opts.TitleOpts("某商店{}年营业额".format(i)))
)
tl.add(pie, "{}年".format(i))
return tl
@C.funcs
def timeline_map() -> Timeline:
tl = Timeline()
for i in range(2015, 2020):
map0 = (
Map()
.add(
"商家A", [list(z) for z in zip(Faker.provinces, Faker.values())], "china"
)
.set_global_opts(
title_opts=opts.TitleOpts(title="Map-{}年某些数据".format(i)),
visualmap_opts=opts.VisualMapOpts(max_=200),
)
)
tl.add(map0, "{}年".format(i))
return tl
@C.funcs
def timeline_with_multi_axis() -> Timeline:
tl = Timeline()
for i in range(2015, 2020):
bar = (
Bar()
.add_xaxis(Faker.choose())
.add_yaxis("商家A", Faker.values())
.add_yaxis("商家B", Faker.values())
.set_global_opts(title_opts=opts.TitleOpts("某商店{}年营业额".format(i)))
)
tl.add(bar, "{}年".format(i))
return tl
@C.funcs
def timeline_sankey() -> Timeline:
tl = Timeline()
names = ("商家A", "商家B", "商家C")
nodes = [{"name": name} for name in names]
for i in range(2015, 2020):
links = [
{"source": names[0], "target": names[1], "value": Faker.values()[0]},
{"source": names[1], "target": names[2], "value": Faker.values()[0]},
]
sankey = (
Sankey()
.add(
"sankey",
nodes,
links,
linestyle_opt=opts.LineStyleOpts(
opacity=0.2, curve=0.5, color="source"
),
label_opts=opts.LabelOpts(position="right"),
)
.set_global_opts(
title_opts=opts.TitleOpts(title="{}年商店（A, B, C）营业额差".format(i))
)
)
tl.add(sankey, "{}年".format(i))
return tl
Page().add(*[fn() for fn, _ in C.charts]).render()
| 31.888889 | 87 | 0.428765 |
2aa433ffe89df068aaa06b0e7dbd4f839ceb7dde | 8,093 | py | Python | desktop/libs/libanalyze/src/libanalyze/models.py | yetsun/hue | 2e48f0cc70e233ee0e1b40733d4b2a18d8836c66 | [
"Apache-2.0"
]
| 5,079 | 2015-01-01T03:39:46.000Z | 2022-03-31T07:38:22.000Z | desktop/libs/libanalyze/src/libanalyze/models.py | yetsun/hue | 2e48f0cc70e233ee0e1b40733d4b2a18d8836c66 | [
"Apache-2.0"
]
| 1,623 | 2015-01-01T08:06:24.000Z | 2022-03-30T19:48:52.000Z | desktop/libs/libanalyze/src/libanalyze/models.py | yetsun/hue | 2e48f0cc70e233ee0e1b40733d4b2a18d8836c66 | [
"Apache-2.0"
]
| 2,033 | 2015-01-04T07:18:02.000Z | 2022-03-28T19:55:47.000Z | #!/usr/bin/env python
# Licensed to Cloudera, Inc. under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. Cloudera, Inc. 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 builtins import object
import json
from itertools import groupby
from functools import reduce
class Contributor(object):
def __init__(self, **kwargs):
self.id = None
self.query_id = None
self.type = None
self.wall_clock_time = None
self.plan_node_id = None
self.plan_node_name = None
self.reason = None
self.__dict__.update(kwargs)
def to_json(self):
return json.dumps(self.__dict__)
class Reason(object):
def __init__(self, **kwargs):
self.name = None
self.message = None
self.impact = None
self.unit = None
self.fix = None
self.__dict__.update(kwargs)
def to_json(self):
return json.dumps(self.__dict__)
class TCounter(object):
def __init__(self, **kwargs):
self.value = None
self.name = None
self.unit = None
self.__dict__.update(kwargs)
def query_node_by_id(profile, node_id, metric_name, averaged=False):
"""Given the query_id, searches for the corresponding query profile and
selects the node instances given by node_id, selects the metric given by
metric_name and groups by fragment and fragment instance."""
result = profile.find_by_id(node_id)
if not result:
return result
nodes = _filter_averaged(result, averaged)
metric = reduce(lambda x, y: x + y.find_metric_by_name(metric_name), nodes, [])
return [L(x['value'], x['unit'], 0, x['node'].fragment.id(), x['node'].host(), 0, x['node'].id(), x['node'].name(), value=x['value'], unit=x['unit'], fragment_id=0, fid=x['node'].fragment.id(), host=x['node'].host(), node_id=x['node'].id(), name=x['node'].name(), node=x['node']) for x in metric]
def query_node_by_id_value(profile, node_id, metric_name, averaged=False, default=0):
results = query_node_by_id(profile, node_id, metric_name, averaged)
return results and results[0][0] or default
def _filter_averaged(result, averaged=False):
#nodes = filter(lambda x: x.fragment.is_averaged() == averaged, result)
# Averaged results are not always present. If we're looking for averaged results, sort by averaged and get first result (hopefully getting averaged!).
# If we're not looking for averaged results, remove them.
if averaged:
def by_averaged(x, y):
if x.fragment.is_averaged():
return -1
elif y.fragment.is_averaged():
return 1
else:
return 0
return sorted(result, cmp=by_averaged)
else:
return [x for x in result if x.fragment.is_averaged() == averaged]
def query_node_by_metric(profile, node_name, metric_name):
"""Given the query_id, searches for the corresponding query profile and
selects the node instances given by node_name, selects the metric given by
metric_name and groups by fragment and fragment instance."""
result = profile.find_all_by_name(node_name)
nodes = [x for x in result if x.fragment.is_averaged() == False]
metric = reduce(lambda x, y: x + y.find_metric_by_name(metric_name), nodes, [])
return [L(x['value'], 0, x['node'].fragment.id(), x['node'].host(), 0, x['node'].id(), x['node'].name(), value=x['value'], unit=x['unit'], fragment_id=0, fid=x['node'].fragment.id(), host=x['node'].host(), node_id=x['node'].id(), name=x['node'].name(), node=x['node']) for x in metric]
def query_element_by_metric(profile, node_name, metric_name):
"""Given the query_id, searches for the corresponding query profile and
selects the node instances given by node_name, selects the metric given by
metric_name and groups by fragment and fragment instance."""
result = profile.find_all_by_name(node_name)
nodes = [x for x in result if not x.fragment or x.fragment.is_averaged() == False]
metric = reduce(lambda x, y: x + y.find_metric_by_name(metric_name), nodes, [])
return [L(x['value'], 0, x['node'].fragment.id() if x['node'].fragment else '', x['node'].host(), 0, x['node'].id(), x['node'].name(), value=x['value'], unit=x['unit'], fragment_id=0, fid=x['node'].fragment.id() if x['node'].fragment else '', host=x['node'].host(), node_id=x['node'].id(), name=x['node'].name(), node=x['node']) for x in metric]
def query_element_by_info(profile, node_name, metric_name):
"""Given the query_id, searches for the corresponding query profile and
selects the node instances given by node_name, selects the metric given by
metric_name and groups by fragment and fragment instance."""
result = profile.find_all_by_name(node_name)
nodes = [x for x in result if not x.fragment or x.fragment.is_averaged() == False]
metric = reduce(lambda x, y: x + y.find_info_by_name(metric_name), nodes, [])
return [L(x['value'], 0, x['node'].fragment.id() if x['node'].fragment else '', x['node'].host(), 0, x['node'].id(), x['node'].name(), value=x['value'], fragment_id=0, fid=x['node'].fragment.id() if x['node'].fragment else '', host=x['node'].host(), node_id=x['node'].id(), name=x['node'].name(), node=x['node']) for x in metric]
def query_avg_fragment_metric_by_node_nid(profile, node_nid, metric_name, default):
"""
Given the surragate node id (i.e. unique id of the plan node in the database),
return the value of the fragment level metric.
:param node_id:
:param metric_name:
:return: the value of the metric; none if there is no result
"""
result = profile.find_by_id(node_nid)
if not result:
return result
node = _filter_averaged(result, True)[0]
metric = node.fragment.find_metric_by_name(metric_name)
return metric and metric[0]['value'] or default
def query_fragment_metric_by_node_id(node, metric_name):
"""
Given the surragate node id (i.e. unique id of the plan node in the database),
return the value of the fragment level metric.
:param node_id:
:param metric_name:
:return: the value of the metric; none if there is no result
"""
metrics = node.find_metric_by_name(metric_name)
return metrics[0]['value'] if metrics else None
def query_unique_node_by_id(profile, fragment_id, fragment_instance_id, node_id):
result = profile.find_by_id(node_id)
nodes = [x for x in result if ((x.fragment is None and x.is_fragment()) or x.fragment.id() == fragment_id) and x.fragment_instance.id() == fragment_instance_id]
return nodes[0]
def host_by_metric(profile, metric_name, exprs=[max]):
"""Queries all fragment instances for a particular associated metric value.
Calculates the aggregated value based on exprs."""
fragments = profile.find_all_fragments()
fragments = [x for x in fragments if x.is_averaged() == False]
metrics = reduce(lambda x,y: x + y.find_metric_by_name(metric_name), fragments, [])
results = L(unit=-1)
for k, g in groupby(metrics, lambda x: x['node'].host()):
grouped = list(g)
values = [x['value'] for x in grouped]
result = [k]
for expr in exprs:
value = expr(values)
result.append(value)
results.append(result)
if grouped:
results.unit = grouped[0]['unit']
return results
class L(list):
def __new__(self, *args, **kwargs):
return super(L, self).__new__(self, args, kwargs)
def __init__(self, *args, **kwargs):
if len(args) == 1 and hasattr(args[0], '__iter__'):
list.__init__(self, args[0])
else:
list.__init__(self, args)
self.__dict__.update(kwargs)
def __call__(self, **kwargs):
self.__dict__.update(kwargs)
return self
| 43.983696 | 347 | 0.701594 |
b162a41145e7b31467785d742834f28630ea3fcb | 11,470 | py | Python | cloudmonkey/requester.py | mrehman29/cloudmonkey-interoute | 9ca30487f60ca328ee33415dc1f125f57978f93a | [
"Apache-2.0"
]
| null | null | null | cloudmonkey/requester.py | mrehman29/cloudmonkey-interoute | 9ca30487f60ca328ee33415dc1f125f57978f93a | [
"Apache-2.0"
]
| 1 | 2021-02-02T23:02:09.000Z | 2021-02-02T23:02:09.000Z | cloudmonkey/requester.py | mrehman29/cloudmonkey-interoute | 9ca30487f60ca328ee33415dc1f125f57978f93a | [
"Apache-2.0"
]
| null | null | null | #!/usr/bin/python
# -*- coding: utf-8 -*-
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
try:
import base64
import hashlib
import hmac
import itertools
import json
import requests
import ssl
import sys
import time
import urllib
import urllib2
from datetime import datetime, timedelta
from requests_toolbelt import SSLAdapter
from urllib2 import HTTPError, URLError
except ImportError, e:
print "Import error in %s : %s" % (__name__, e)
import sys
sys.exit()
# Disable HTTPS verification warnings.
from requests.packages import urllib3
urllib3.disable_warnings()
def logger_debug(logger, message):
if logger is not None:
logger.debug(message)
def writeError(msg):
sys.stderr.write(msg)
sys.stderr.write("\n")
sys.stderr.flush()
def login(url, username, password, domain="/", verifysslcert=False):
"""
Login and obtain a session to be used for subsequent API calls
Wrong username/password leads to HTTP error code 531
"""
args = {}
args["command"] = 'login'
args["username"] = username
args["password"] = password
args["domain"] = domain
args["response"] = "json"
sessionkey = ''
session = requests.Session()
session.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
try:
resp = session.post(url, params=args, verify=verifysslcert)
except requests.exceptions.ConnectionError, e:
writeError("Connection refused by server: %s" % e)
return None, None
if resp.status_code == 200:
sessionkey = resp.json()['loginresponse']['sessionkey']
elif resp.status_code == 405:
writeError("Method not allowed, unauthorized access on URL: %s" % url)
session = None
sessionkey = None
elif resp.status_code == 531:
writeError("Error authenticating at %s using username: %s"
", password: %s, domain: %s" % (url, username, password,
domain))
session = None
sessionkey = None
else:
resp.raise_for_status()
return session, sessionkey
def logout(url, session):
if not session:
return
session.get(url, params={'command': 'logout'})
def make_request_with_password(command, args, logger, url, credentials,
verifysslcert=False):
error = None
args = args.copy()
username = credentials['username']
password = credentials['password']
domain = credentials['domain']
if not (username and password):
error = "Username and password cannot be empty"
result = None
return result, error
tries = 0
retry = True
while tries < 2 and retry:
sessionkey = credentials.get('sessionkey')
session = credentials.get('session')
tries += 1
# obtain a valid session if not supplied
if not (session and sessionkey):
session, sessionkey = login(url, username, password, domain,
verifysslcert)
if not (session and sessionkey):
return None, 'Authentication failed'
credentials['session'] = session
credentials['sessionkey'] = sessionkey
args['sessionkey'] = sessionkey
# make the api call
resp = session.get(url, params=args, verify=verifysslcert)
result = resp.text
logger_debug(logger, "Response received: %s" % resp.text)
if resp.status_code == 200: # success
retry = False
break
if resp.status_code == 401: # sessionkey is wrong
credentials['session'] = None
credentials['sessionkey'] = None
continue
if resp.status_code != 200 and resp.status_code != 401:
error_message = resp.headers.get('X-Description')
if not error_message:
error_message = resp.text
error = "{0}: {1}".format(resp.status_code, error_message)
result = None
retry = False
return result, error
def make_request(command, args, logger, url, credentials, expires, region,
verifysslcert=False, signatureversion=3):
result = None
error = None
if not url.startswith('http'):
error = "Server URL should start with 'http' or 'https', " + \
"please check and fix the url"
return None, error
if not args:
args = {}
args = args.copy()
args["command"] = command
args["region"] = region
args["response"] = "json"
signatureversion = int(signatureversion)
if signatureversion >= 3:
args["signatureversion"] = signatureversion
if not expires:
expires = 600
expirationtime = datetime.utcnow() + timedelta(seconds=int(expires))
args["expires"] = expirationtime.strftime('%Y-%m-%dT%H:%M:%S+0000')
for key in args.keys():
value = args[key]
if isinstance(value, unicode):
value = value.encode("utf-8")
args[key] = value
if not key:
args.pop(key)
# try to use the apikey/secretkey method by default
# followed by trying to check if we're using integration port
# finally use the username/password method
if not credentials['apikey'] and not ("8096" in url):
try:
return make_request_with_password(command, args, logger, url,
credentials, verifysslcert)
except (requests.exceptions.ConnectionError, Exception), e:
return None, e
def sign_request(params, secret_key):
request = zip(params.keys(), params.values())
request.sort(key=lambda x: x[0].lower())
hash_str = "&".join(
["=".join(
[r[0].lower(),
urllib.quote_plus(str(r[1]), safe="*").lower()
.replace("+", "%20").replace("%3A", ":")]
) for r in request]
)
return base64.encodestring(hmac.new(secret_key, hash_str,
hashlib.sha1).digest()).strip()
args['apiKey'] = credentials['apikey']
args["signature"] = sign_request(args, credentials['secretkey'])
session = requests.Session()
session.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
try:
response = session.get(url, params=args, verify=verifysslcert)
logger_debug(logger, "Request sent: %s" % response.url)
result = response.text
if response.status_code == 200: # success
error = None
elif response.status_code == 401: # auth issue
error = "401 Authentication error"
elif response.status_code != 200 and response.status_code != 401:
error = "{0}: {1}".format(response.status_code,
response.headers.get('X-Description'))
except requests.exceptions.ConnectionError, e:
return None, "Connection refused by server: %s" % e
except Exception, pokemon:
error = pokemon.message
logger_debug(logger, "Response received: %s" % result)
if error is not None:
logger_debug(logger, "Error: %s" % (error))
return result, error
return result, error
def monkeyrequest(command, args, isasync, asyncblock, logger, url,
credentials, timeout, expires, region, verifysslcert=False, signatureversion=3):
response = None
error = None
logger_debug(logger, "======== START Request ========")
logger_debug(logger, "Requesting command=%s, args=%s" % (command, args))
response, error = make_request(command, args, logger, url,
credentials, expires, region, verifysslcert, signatureversion)
logger_debug(logger, "======== END Request ========\n")
if error is not None and not response:
return response, error
def process_json(response):
try:
response = json.loads(response, "utf-8")
except ValueError, e:
logger_debug(logger, "Error processing json: %s" % e)
writeError("Error processing json: %s" % e)
response = None
error = e
return response
response = process_json(response)
if not response or not isinstance(response, dict):
return response, error
m = list(v for v in response.keys() if 'response' in v.lower())
if not m:
return response, 'Invalid response received: %s' % response
isasync = isasync and (asyncblock == "true" or asyncblock == "True")
responsekey = filter(lambda x: 'response' in x, response.keys())[0]
if isasync and 'jobid' in response[responsekey]:
jobid = response[responsekey]['jobid']
command = "queryAsyncJobResult"
request = {'jobid': jobid}
if not timeout:
timeout = 3600
timeout = int(timeout)
cursor = itertools.cycle([u'|', u'/', u'-', u'\\'])
while timeout > 0:
interval = 2
while interval > 0:
sys.stdout.write(u"%s\r" % cursor.next())
sys.stdout.flush()
time.sleep(0.1)
interval -= 0.1
timeout = timeout - 2
logger_debug(logger, "Job %s to timeout in %ds" % (jobid, timeout))
response, error = make_request(command, request, logger, url,
credentials, expires, region, verifysslcert, signatureversion)
if error and not response:
return response, error
response = process_json(response)
responsekeys = filter(lambda x: 'response' in x, response.keys())
if len(responsekeys) < 1:
continue
result = response[responsekeys[0]]
if "errorcode" in result or "errortext" in result:
return response, error
jobstatus = result['jobstatus']
if jobstatus == 2:
jobresult = result["jobresult"]
error = "\rAsync job %s failed\nError %s, %s" % (
jobid, jobresult["errorcode"], jobresult["errortext"])
return response, error
elif jobstatus == 1:
sys.stdout.write(u"\r \n")
sys.stdout.flush()
return response, error
elif jobstatus == 0:
pass # Job in progress
else:
logger_debug(logger, "We should not arrive here!")
sys.stdout.flush()
error = "Error: Async query timeout occurred for jobid %s" % jobid
return response, error
| 34.341317 | 105 | 0.593287 |
f096ac21d626174df3732a272c5dfdfe83ad3677 | 2,324 | py | Python | onnxmltools/convert/xgboost/convert.py | xhochy/onnxmltools | cb2782b155ff67dc1e586f36a27c5d032070c801 | [
"Apache-2.0"
]
| 1 | 2022-01-28T04:59:37.000Z | 2022-01-28T04:59:37.000Z | onnxmltools/convert/xgboost/convert.py | xhochy/onnxmltools | cb2782b155ff67dc1e586f36a27c5d032070c801 | [
"Apache-2.0"
]
| null | null | null | onnxmltools/convert/xgboost/convert.py | xhochy/onnxmltools | cb2782b155ff67dc1e586f36a27c5d032070c801 | [
"Apache-2.0"
]
| 1 | 2021-07-05T23:51:56.000Z | 2021-07-05T23:51:56.000Z | # SPDX-License-Identifier: Apache-2.0
from uuid import uuid4
import xgboost
from onnxconverter_common.onnx_ex import get_maximum_opset_supported
import onnx
from ..common._topology import convert_topology
from ._parse import parse_xgboost, WrappedBooster
# Invoke the registration of all our converters and shape calculators
# from . import shape_calculators
from . import operator_converters, shape_calculators
def convert(model, name=None, initial_types=None, doc_string='', target_opset=None,
targeted_onnx=onnx.__version__, custom_conversion_functions=None,
custom_shape_calculators=None):
'''
This function produces an equivalent ONNX model of the given xgboost model.
:param model: A xgboost model
:param initial_types: a python list. Each element is a tuple of a variable name and a type defined in data_types.py
:param name: The name of the graph (type: GraphProto) in the produced ONNX model (type: ModelProto)
:param doc_string: A string attached onto the produced ONNX model
:param target_opset: number, for example, 7 for ONNX 1.2, and 8 for ONNX 1.3.
:param targeted_onnx: A string (for example, '1.1.2' and '1.2') used to specify the targeted ONNX version of the
produced model. If ONNXMLTools cannot find a compatible ONNX python package, an error may be thrown.
:param custom_conversion_functions: a dictionary for specifying the user customized conversion function
:param custom_shape_calculators: a dictionary for specifying the user customized shape calculator
:return: An ONNX model (type: ModelProto) which is equivalent to the input xgboost model
'''
if initial_types is None:
raise ValueError('Initial types are required. See usage of convert(...) in \
onnxmltools.convert.xgboost.convert for details')
if name is None:
name = str(uuid4().hex)
if isinstance(model, xgboost.Booster):
model = WrappedBooster(model)
target_opset = target_opset if target_opset else get_maximum_opset_supported()
topology = parse_xgboost(model, initial_types, target_opset, custom_conversion_functions, custom_shape_calculators)
topology.compile()
onnx_model = convert_topology(topology, name, doc_string, target_opset, targeted_onnx)
return onnx_model
| 51.644444 | 119 | 0.755164 |
01f5cd14fa2560392a0804beb892d9c40e0ee401 | 3,610 | py | Python | src/scripts/training/lgb_baseline_fillna_999.py | arnabbiswas1/k_tab_sept_roc_auc_binary_classification_KFold | 7a5a91e52d460fd25133b76d5241462a4aedc474 | [
"Apache-2.0"
]
| null | null | null | src/scripts/training/lgb_baseline_fillna_999.py | arnabbiswas1/k_tab_sept_roc_auc_binary_classification_KFold | 7a5a91e52d460fd25133b76d5241462a4aedc474 | [
"Apache-2.0"
]
| null | null | null | src/scripts/training/lgb_baseline_fillna_999.py | arnabbiswas1/k_tab_sept_roc_auc_binary_classification_KFold | 7a5a91e52d460fd25133b76d5241462a4aedc474 | [
"Apache-2.0"
]
| null | null | null | """
LGB benchmark KFold-5 fillna 99999
"""
import os
from timeit import default_timer as timer
from datetime import datetime
import pandas as pd
from sklearn.model_selection import KFold
import src.common as common
import src.config.constants as constants
import src.munging as process_data
import src.modeling as model
common.set_timezone()
start = timer()
# Create RUN_ID
RUN_ID = datetime.now().strftime("%m%d_%H%M")
MODEL_NAME = os.path.basename(__file__).split(".")[0]
SEED = 42
EXP_DETAILS = "LGB benchmark KFold-5 fillna 99999"
TARGET = "claim"
N_SPLIT = 5
MODEL_TYPE = "lgb"
OBJECTIVE = "binary"
BOOSTING_TYPE = "gbdt"
METRIC = "auc"
VERBOSE = 100
N_THREADS = -1
NUM_LEAVES = 31
MAX_DEPTH = -1
N_ESTIMATORS = 10000
LEARNING_RATE = 0.1
EARLY_STOPPING_ROUNDS = 100
lgb_params = {
"objective": OBJECTIVE,
"boosting_type": BOOSTING_TYPE,
"learning_rate": LEARNING_RATE,
"num_leaves": NUM_LEAVES,
"tree_learner": "serial",
"n_jobs": N_THREADS,
"seed": SEED,
"max_depth": MAX_DEPTH,
"max_bin": 255,
"metric": METRIC,
"verbose": -1,
}
LOGGER_NAME = "sub_1"
logger = common.get_logger(LOGGER_NAME, MODEL_NAME, RUN_ID, constants.LOG_DIR)
common.set_seed(SEED)
logger.info(f"Running for Model Number [{MODEL_NAME}] & [{RUN_ID}]")
common.update_tracking(RUN_ID, "model_number", MODEL_NAME, drop_incomplete_rows=True)
common.update_tracking(RUN_ID, "model_type", MODEL_TYPE)
common.update_tracking(RUN_ID, "metric", "roc_auc")
common.update_tracking(RUN_ID, "n_estimators", N_ESTIMATORS)
common.update_tracking(RUN_ID, "learning_rate", LEARNING_RATE)
common.update_tracking(RUN_ID, "num_leaves", NUM_LEAVES)
common.update_tracking(RUN_ID, "early_stopping_rounds", EARLY_STOPPING_ROUNDS)
train_df, test_df, sample_submission_df = process_data.read_processed_fillna_data(
logger,
constants.PROCESSED_DATA_DIR,
train=True,
test=True,
sample_submission=True,
)
combined_df = pd.concat([train_df.drop(TARGET, axis=1), test_df])
target = train_df[TARGET]
train_df = combined_df.loc[train_df.index]
train_df[TARGET] = target
test_df = combined_df.loc[test_df.index]
train_X = train_df.drop([TARGET], axis=1)
train_Y = train_df[TARGET]
test_X = test_df
logger.info(
f"Shape of train_X : {train_X.shape}, test_X: {test_X.shape}, train_Y: {train_Y.shape}"
)
predictors = list(train_X.columns)
kfold = KFold(n_splits=N_SPLIT, random_state=SEED, shuffle=True)
common.update_tracking(RUN_ID, "no_of_features", len(predictors), is_integer=True)
common.update_tracking(RUN_ID, "cv_method", "KFold")
common.update_tracking(RUN_ID, "n_fold", N_SPLIT)
results_dict = model.lgb_train_validate_on_cv(
logger,
run_id=RUN_ID,
train_X=train_X,
train_Y=train_Y,
test_X=test_X,
metric="roc_auc",
kf=kfold,
features=predictors,
params=lgb_params,
n_estimators=N_ESTIMATORS,
early_stopping_rounds=EARLY_STOPPING_ROUNDS,
cat_features="auto",
verbose_eval=100,
)
common.update_tracking(RUN_ID, "lb_score", 0, is_integer=True)
train_index = train_df.index
common.save_artifacts(
logger,
target=TARGET,
is_plot_fi=True,
result_dict=results_dict,
submission_df=sample_submission_df,
train_index=train_index,
model_number=MODEL_NAME,
run_id=RUN_ID,
sub_dir=constants.SUBMISSION_DIR,
oof_dir=constants.OOF_DIR,
fi_dir=constants.FI_DIR,
fi_fig_dir=constants.FI_FIG_DIR,
)
end = timer()
common.update_tracking(RUN_ID, "training_time", end - start, is_integer=True)
common.update_tracking(RUN_ID, "comments", EXP_DETAILS)
logger.info("Execution Complete")
| 25.422535 | 91 | 0.749584 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.